mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-28 14:06:08 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/clang/lib/AST/ASTDiagnostic.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

2193 lines
80 KiB
C++
Raw Normal View History

Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
//===--- ASTDiagnostic.cpp - Diagnostic Printing Hooks for AST Nodes ------===//
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 08:50:56 +00:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
//
//===----------------------------------------------------------------------===//
//
// This file implements a diagnostic formatting hook for AST elements.
//
//===----------------------------------------------------------------------===//
Fix some Clang-tidy readability-redundant-control-flow warnings; other minor fixes. Differential revision: http://reviews.llvm.org/D17060 llvm-svn: 260414
2016-02-10 19:11:58 +00:00
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
#include "clang/AST/ASTDiagnostic.h"
#include "clang/AST/ASTContext.h"
Implement -Wframe-larger-than backend diagnostic Add driver and frontend support for the GCC -Wframe-larger-than=bytes warning. This is the first GCC-compatible backend diagnostic built around LLVM's reporting feature. This commit adds infrastructure to perform reverse lookup from mangled names emitted after LLVM IR generation. We use that to resolve precise locations and originating AST functions, lambdas or block declarations to produce seamless codegen-guided diagnostics. An associated change, StringMap now maintains unique mangled name strings instead of allocating copies. This is a net memory saving in C++ and a small hit for C where we no longer reuse IdentifierInfo storage, pending further optimisation. llvm-svn: 210293
2014-06-05 22:10:59 +00:00
#include "clang/AST/ASTLambda.h"
Teach the diagnostics engine about the Attr type to make reporting on semantic attributes easier (and not require hard-coded strings). This requires a getSpelling() function on the Attr class, which is table-driven. Updates a handful of cases where a hard-coded string was being used to test the functionality out. Updating associated test cases for the improved quoting. llvm-svn: 198055
2013-12-26 18:30:57 +00:00
#include "clang/AST/Attr.h"
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
#include "clang/AST/DeclObjC.h"
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
#include "clang/AST/DeclTemplate.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 09:13:33 +00:00
#include "clang/AST/ExprCXX.h"
#include "clang/AST/TemplateBase.h"
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
#include "clang/AST/Type.h"
[ADT] Remove APInt/APSInt toString() std::string variants <string> is currently the highest impact header in a clang+llvm build: https://commondatastorage.googleapis.com/chromium-browser-clang/llvm-include-analysis.html One of the most common places this is being included is the APInt.h header, which needs it for an old toString() implementation that returns std::string - an inefficient method compared to the SmallString versions that it actually wraps. This patch replaces these APInt/APSInt methods with a pair of llvm::toString() helpers inside StringExtras.h, adjusts users accordingly and removes the <string> from APInt.h - I was hoping that more of these users could be converted to use the SmallString methods, but it appears that most end up creating a std::string anyhow. I avoided trying to use the raw_ostream << operators as well as I didn't want to lose having the integer radix explicit in the code. Differential Revision: https://reviews.llvm.org/D103888
2021-06-11 13:19:00 +01:00
#include "llvm/ADT/StringExtras.h"
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
#include "llvm/Support/raw_ostream.h"
using namespace clang;
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
// Returns a desugared version of the QualType, and marks ShouldAKA as true
[clang][NFC] Add a notice to desugarForDiagnostic `desugarForDiagnostic` only sets ShouldAKA to true if desugaring happens, otherwise ShouldAKA is left intact and might be uninitialized. Victims (including me): https://github.com/llvm/llvm-project/commit/25bf8cb3c0e3c41231289a6ff0a37b6d49b24011 https://github.com/llvm/llvm-project/commit/0e8384a0fe4f03d60cd92aba1cae074512481ca2 Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D152880
2023-06-14 09:59:30 +08:00
// whenever we remove significant sugar from the type. Make sure ShouldAKA
// is initialized before passing it in.
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
QualType clang::desugarForDiagnostic(ASTContext &Context, QualType QT,
bool &ShouldAKA) {
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
QualifierCollector QC;
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
while (true) {
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
const Type *Ty = QC.strip(QT);
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
// Don't aka just because we saw an elaborated type...
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 03:19:35 +00:00
if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(Ty)) {
QT = ET->desugar();
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
continue;
}
Reland "[AST] Add UsingType: a sugar type for types found via UsingDecl" This reverts commit cc56c66f27e131b914082d3bd21180646e842e9a. Fixed a bad assertion, the target of a UsingShadowDecl must not have *local* qualifiers, but it can be a typedef whose underlying type is qualified.
2021-12-20 18:01:33 +01:00
// ... or a using type ...
if (const UsingType *UT = dyn_cast<UsingType>(Ty)) {
QT = UT->desugar();
continue;
}
Added ParenType type node. llvm-svn: 121488
2010-12-10 16:29:40 +00:00
// ... or a paren type ...
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 03:19:35 +00:00
if (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
QT = PT->desugar();
Added ParenType type node. llvm-svn: 121488
2010-12-10 16:29:40 +00:00
continue;
}
Recommit r359859 "[Attribute/Diagnostics] Print macro if definition is an attribute declaration" Updated with fix for read of uninitialized memory. llvm-svn: 360109
2019-05-07 03:20:17 +00:00
// ... or a macro defined type ...
if (const MacroQualifiedType *MDT = dyn_cast<MacroQualifiedType>(Ty)) {
QT = MDT->desugar();
continue;
}
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 03:19:35 +00:00
// ...or a substituted template type parameter ...
if (const SubstTemplateTypeParmType *ST =
dyn_cast<SubstTemplateTypeParmType>(Ty)) {
QT = ST->desugar();
continue;
}
Make AttributedTypes for GC-qualified types and fix some miscellaneous bugs with such types. Not sure this is quite how I want the desugaring and a.k.a. logic to go, but it suffices. llvm-svn: 126986
2011-03-04 04:00:19 +00:00
// ...or an attributed type...
if (const AttributedType *AT = dyn_cast<AttributedType>(Ty)) {
QT = AT->desugar();
continue;
}
Add an AdjustedType sugar node for adjusting calling conventions Summary: In general, this type node can be used to represent any type adjustment that occurs implicitly without losing type sugar. The immediate use of this is to adjust the calling conventions of member function pointer types without breaking template instantiation. Fixes PR17996. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2332 llvm-svn: 196451
2013-12-05 01:23:43 +00:00
// ...or an adjusted type...
if (const AdjustedType *AT = dyn_cast<AdjustedType>(Ty)) {
QT = AT->desugar();
continue;
}
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 03:19:35 +00:00
// ... or an auto type.
if (const AutoType *AT = dyn_cast<AutoType>(Ty)) {
if (!AT->isSugared())
break;
QT = AT->desugar();
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
continue;
}
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
PR10405 - Desugar FunctionType and TemplateSpecializationType if any type that appears inside needs to be desugared. llvm-svn: 242371
2015-07-16 01:06:17 +00:00
// Desugar FunctionType if return type or any parameter type should be
// desugared. Preserve nullability attribute on desugared types.
if (const FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
bool DesugarReturn = false;
QualType SugarRT = FT->getReturnType();
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
QualType RT = desugarForDiagnostic(Context, SugarRT, DesugarReturn);
PR10405 - Desugar FunctionType and TemplateSpecializationType if any type that appears inside needs to be desugared. llvm-svn: 242371
2015-07-16 01:06:17 +00:00
if (auto nullability = AttributedType::stripOuterNullability(SugarRT)) {
[clang/AST] Make it possible to use SwiftAttr in type context (#108631) Swift ClangImporter now supports concurrency annotations on imported declarations and their parameters/results, to make it possible to use imported APIs in Swift safely there has to be a way to annotate individual parameters and result types with relevant attributes that indicate that e.g. a block is called on a particular actor or it accepts a `Sendable` parameter. To faciliate that `SwiftAttr` is switched from `InheritableAttr` which is a declaration attribute to `DeclOrTypeAttr`. To support this attribute in type context we need access to its "Attribute" argument which requires `AttributedType` to be extended to include `Attr *` when available instead of just `attr::Kind` otherwise it won't be possible to determine what attribute should be imported.
2024-10-31 04:15:22 -07:00
RT = Context.getAttributedType(*nullability, RT, RT);
PR10405 - Desugar FunctionType and TemplateSpecializationType if any type that appears inside needs to be desugared. llvm-svn: 242371
2015-07-16 01:06:17 +00:00
}
bool DesugarArgument = false;
SmallVector<QualType, 4> Args;
const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT);
if (FPT) {
for (QualType SugarPT : FPT->param_types()) {
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
QualType PT = desugarForDiagnostic(Context, SugarPT, DesugarArgument);
PR10405 - Desugar FunctionType and TemplateSpecializationType if any type that appears inside needs to be desugared. llvm-svn: 242371
2015-07-16 01:06:17 +00:00
if (auto nullability =
AttributedType::stripOuterNullability(SugarPT)) {
[clang/AST] Make it possible to use SwiftAttr in type context (#108631) Swift ClangImporter now supports concurrency annotations on imported declarations and their parameters/results, to make it possible to use imported APIs in Swift safely there has to be a way to annotate individual parameters and result types with relevant attributes that indicate that e.g. a block is called on a particular actor or it accepts a `Sendable` parameter. To faciliate that `SwiftAttr` is switched from `InheritableAttr` which is a declaration attribute to `DeclOrTypeAttr`. To support this attribute in type context we need access to its "Attribute" argument which requires `AttributedType` to be extended to include `Attr *` when available instead of just `attr::Kind` otherwise it won't be possible to determine what attribute should be imported.
2024-10-31 04:15:22 -07:00
PT = Context.getAttributedType(*nullability, PT, PT);
PR10405 - Desugar FunctionType and TemplateSpecializationType if any type that appears inside needs to be desugared. llvm-svn: 242371
2015-07-16 01:06:17 +00:00
}
Args.push_back(PT);
}
}
if (DesugarReturn || DesugarArgument) {
ShouldAKA = true;
QT = FPT ? Context.getFunctionType(RT, Args, FPT->getExtProtoInfo())
: Context.getFunctionNoProtoType(RT, FT->getExtInfo());
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-05 21:57:07 +00:00
break;
PR10405 - Desugar FunctionType and TemplateSpecializationType if any type that appears inside needs to be desugared. llvm-svn: 242371
2015-07-16 01:06:17 +00:00
}
}
// Desugar template specializations if any template argument should be
// desugared.
if (const TemplateSpecializationType *TST =
dyn_cast<TemplateSpecializationType>(Ty)) {
if (!TST->isTypeAlias()) {
bool DesugarArgument = false;
SmallVector<TemplateArgument, 4> Args;
NFC: [clang] Template argument cleanups. Removes a bunch of obsolete methods in favor of a single one returning an ArrayRef of TemplateArgument. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D136602
2022-10-24 14:18:46 +02:00
for (const TemplateArgument &Arg : TST->template_arguments()) {
PR10405 - Desugar FunctionType and TemplateSpecializationType if any type that appears inside needs to be desugared. llvm-svn: 242371
2015-07-16 01:06:17 +00:00
if (Arg.getKind() == TemplateArgument::Type)
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
Args.push_back(desugarForDiagnostic(Context, Arg.getAsType(),
DesugarArgument));
PR10405 - Desugar FunctionType and TemplateSpecializationType if any type that appears inside needs to be desugared. llvm-svn: 242371
2015-07-16 01:06:17 +00:00
else
Args.push_back(Arg);
}
if (DesugarArgument) {
ShouldAKA = true;
QT = Context.getTemplateSpecializationType(
Reland: [clang] Improved canonicalization for template specialization types (#135414) This relands https://github.com/llvm/llvm-project/pull/135119, after fixing crashes seen in LLDB CI reported here: https://github.com/llvm/llvm-project/pull/135119#issuecomment-2794910840 Fixes https://github.com/llvm/llvm-project/pull/135119 This changes the TemplateArgument representation to hold a flag indicating whether a tempalte argument of expression type is supposed to be canonical or not. This gets one step closer to solving https://github.com/llvm/llvm-project/issues/92292 This still doesn't try to unique as-written TSTs. While this would increase the amount of memory savings and make code dealing with the AST more well-behaved, profiling template argument lists is still too expensive for this to be worthwhile, at least for now. This also fixes the context creation of TSTs, so that they don't in some cases get incorrectly flagged as sugar over their own canonical form. This is captured in the test expectation change of some AST dumps. This fixes some places which were unnecessarily canonicalizing these TSTs.
2025-04-12 14:26:30 -03:00
TST->getTemplateName(), Args, /*CanonicalArgs=*/std::nullopt, QT);
PR10405 - Desugar FunctionType and TemplateSpecializationType if any type that appears inside needs to be desugared. llvm-svn: 242371
2015-07-16 01:06:17 +00:00
}
break;
}
}
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
[clang][clangd] Desugar array type. Desugar array type. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D115107
2021-12-09 20:12:48 +08:00
if (const auto *AT = dyn_cast<ArrayType>(Ty)) {
QualType ElementTy =
desugarForDiagnostic(Context, AT->getElementType(), ShouldAKA);
if (const auto *CAT = dyn_cast<ConstantArrayType>(AT))
QT = Context.getConstantArrayType(
ElementTy, CAT->getSize(), CAT->getSizeExpr(),
CAT->getSizeModifier(), CAT->getIndexTypeCVRQualifiers());
else if (const auto *VAT = dyn_cast<VariableArrayType>(AT))
[clang] AST: remove source locations from [Variable/Dependent]SizedArrayType (#135511)
2025-04-14 10:44:25 -03:00
QT = Context.getVariableArrayType(ElementTy, VAT->getSizeExpr(),
VAT->getSizeModifier(),
VAT->getIndexTypeCVRQualifiers());
[clang][clangd] Desugar array type. Desugar array type. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D115107
2021-12-09 20:12:48 +08:00
else if (const auto *DSAT = dyn_cast<DependentSizedArrayType>(AT))
QT = Context.getDependentSizedArrayType(
ElementTy, DSAT->getSizeExpr(), DSAT->getSizeModifier(),
[clang] AST: remove source locations from [Variable/Dependent]SizedArrayType (#135511)
2025-04-14 10:44:25 -03:00
DSAT->getIndexTypeCVRQualifiers());
[clang][clangd] Desugar array type. Desugar array type. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D115107
2021-12-09 20:12:48 +08:00
else if (const auto *IAT = dyn_cast<IncompleteArrayType>(AT))
QT = Context.getIncompleteArrayType(ElementTy, IAT->getSizeModifier(),
IAT->getIndexTypeCVRQualifiers());
else
llvm_unreachable("Unhandled array type");
break;
}
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
// Don't desugar magic Objective-C types.
if (QualType(Ty,0) == Context.getObjCIdType() ||
QualType(Ty,0) == Context.getObjCClassType() ||
QualType(Ty,0) == Context.getObjCSelType() ||
QualType(Ty,0) == Context.getObjCProtoType())
break;
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
// Don't desugar va_list.
Support __builtin_ms_va_list. Summary: This change adds support for `__builtin_ms_va_list`, a GCC extension for variadic `ms_abi` functions. The existing `__builtin_va_list` support is inadequate for this because `va_list` is defined differently in the Win64 ABI vs. the System V/AMD64 ABI. Depends on D1622. Reviewers: rsmith, rnk, rjmccall CC: cfe-commits Differential Revision: http://reviews.llvm.org/D1623 llvm-svn: 247941
2015-09-17 20:55:33 +00:00
if (QualType(Ty, 0) == Context.getBuiltinVaListType() ||
QualType(Ty, 0) == Context.getBuiltinMSVaListType())
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
break;
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
// Otherwise, do a single-step desugar.
QualType Underlying;
bool IsSugar = false;
switch (Ty->getTypeClass()) {
#define ABSTRACT_TYPE(Class, Base)
#define TYPE(Class, Base) \
case Type::Class: { \
const Class##Type *CTy = cast<Class##Type>(Ty); \
if (CTy->isSugared()) { \
IsSugar = true; \
Underlying = CTy->desugar(); \
} \
break; \
}
Rename TypeNodes.def to TypeNodes.inc for consistency across all our autogenerated files. NFC. As requested by Nico Weber. llvm-svn: 373425
2019-10-02 06:35:23 +00:00
#include "clang/AST/TypeNodes.inc"
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
}
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
// If it wasn't sugared, we're done.
if (!IsSugar)
break;
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
// If the desugared type is a vector type, we don't want to expand
// it, it will turn into an attribute mess. People want their "vec4".
if (isa<VectorType>(Underlying))
break;
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
// Don't desugar through the primary typedef of an anonymous type.
revise r112365 to fix the actual problem: the isa<TagType>(Underlying) check in the "typedef for anonymous type" check should have been a getAs. llvm-svn: 113085
2010-09-04 23:16:01 +00:00
if (const TagType *UTT = Underlying->getAs<TagType>())
if (const TypedefType *QTT = dyn_cast<TypedefType>(QT))
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 14:24:37 +00:00
if (UTT->getDecl()->getTypedefNameForAnonDecl() == QTT->getDecl())
revise r112365 to fix the actual problem: the isa<TagType>(Underlying) check in the "typedef for anonymous type" check should have been a getAs. llvm-svn: 113085
2010-09-04 23:16:01 +00:00
break;
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
// Record that we actually looked through an opaque type here.
ShouldAKA = true;
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
QT = Underlying;
}
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
// If we have a pointer-like type, desugar the pointee as well.
// FIXME: Handle other pointer-like types.
if (const PointerType *Ty = QT->getAs<PointerType>()) {
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
QT = Context.getPointerType(
desugarForDiagnostic(Context, Ty->getPointeeType(), ShouldAKA));
Handle Objective-C type arguments. Objective-C type arguments can be provided in angle brackets following an Objective-C interface type. Syntactically, this is the same position as one would provide protocol qualifiers (e.g., id<NSCopying>), so parse both together and let Sema sort out the ambiguous cases. This applies both when parsing types and when parsing the superclass of an Objective-C class, which can now be a specialized type (e.g., NSMutableArray<T> inherits from NSArray<T>). Check Objective-C type arguments against the type parameters of the corresponding class. Verify the length of the type argument list and that each type argument satisfies the corresponding bound. Specializations of parameterized Objective-C classes are represented in the type system as distinct types. Both specialized types (e.g., NSArray<NSString *> *) and unspecialized types (NSArray *) are represented, separately. llvm-svn: 241542
2015-07-07 03:57:35 +00:00
} else if (const auto *Ty = QT->getAs<ObjCObjectPointerType>()) {
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
QT = Context.getObjCObjectPointerType(
desugarForDiagnostic(Context, Ty->getPointeeType(), ShouldAKA));
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
} else if (const LValueReferenceType *Ty = QT->getAs<LValueReferenceType>()) {
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
QT = Context.getLValueReferenceType(
desugarForDiagnostic(Context, Ty->getPointeeType(), ShouldAKA));
Add some tests for reference-collapsing and referencing binding involving rvalue references, to start scoping out what is and what isn't implemented. In the process, tweak some standards citations, type desugaring, and teach the tentative parser about && in ptr-operator. llvm-svn: 123913
2011-01-20 16:08:06 +00:00
} else if (const RValueReferenceType *Ty = QT->getAs<RValueReferenceType>()) {
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
QT = Context.getRValueReferenceType(
desugarForDiagnostic(Context, Ty->getPointeeType(), ShouldAKA));
Handle Objective-C type arguments. Objective-C type arguments can be provided in angle brackets following an Objective-C interface type. Syntactically, this is the same position as one would provide protocol qualifiers (e.g., id<NSCopying>), so parse both together and let Sema sort out the ambiguous cases. This applies both when parsing types and when parsing the superclass of an Objective-C class, which can now be a specialized type (e.g., NSMutableArray<T> inherits from NSArray<T>). Check Objective-C type arguments against the type parameters of the corresponding class. Verify the length of the type argument list and that each type argument satisfies the corresponding bound. Specializations of parameterized Objective-C classes are represented in the type system as distinct types. Both specialized types (e.g., NSArray<NSString *> *) and unspecialized types (NSArray *) are represented, separately. llvm-svn: 241542
2015-07-07 03:57:35 +00:00
} else if (const auto *Ty = QT->getAs<ObjCObjectType>()) {
if (Ty->getBaseType().getTypePtr() != Ty && !ShouldAKA) {
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
QualType BaseType =
desugarForDiagnostic(Context, Ty->getBaseType(), ShouldAKA);
QT = Context.getObjCObjectType(
BaseType, Ty->getTypeArgsAsWritten(),
Move from llvm::makeArrayRef to ArrayRef deduction guides - clang/ part This is a follow-up to https://reviews.llvm.org/D140896, split into several parts as it touches a lot of files. Differential Revision: https://reviews.llvm.org/D141139
2023-01-06 16:56:23 +01:00
llvm::ArrayRef(Ty->qual_begin(), Ty->getNumProtocols()),
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
Ty->isKindOfTypeAsWritten());
Handle Objective-C type arguments. Objective-C type arguments can be provided in angle brackets following an Objective-C interface type. Syntactically, this is the same position as one would provide protocol qualifiers (e.g., id<NSCopying>), so parse both together and let Sema sort out the ambiguous cases. This applies both when parsing types and when parsing the superclass of an Objective-C class, which can now be a specialized type (e.g., NSMutableArray<T> inherits from NSArray<T>). Check Objective-C type arguments against the type parameters of the corresponding class. Verify the length of the type argument list and that each type argument satisfies the corresponding bound. Specializations of parameterized Objective-C classes are represented in the type system as distinct types. Both specialized types (e.g., NSArray<NSString *> *) and unspecialized types (NSArray *) are represented, separately. llvm-svn: 241542
2015-07-07 03:57:35 +00:00
}
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
}
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
It's kindof silly that ExtQuals has an ASTContext&, and we can use that space better. Remove this reference. To make that work, change some APIs (most importantly, getDesugaredType()) to take an ASTContext& if they need to return a QualType. Simultaneously, diminish the need to return a QualType by introducing some useful APIs on SplitQualType, which is just a std::pair<const Type *, Qualifiers>. llvm-svn: 121478
2010-12-10 11:01:00 +00:00
return QC.apply(Context, QT);
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
}
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
/// Convert the given type to a string suitable for printing as part of
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
/// a diagnostic.
///
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
/// There are four main criteria when determining whether we should have an
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
/// a.k.a. clause when pretty-printing a type:
///
/// 1) Some types provide very minimal sugar that doesn't impede the
/// user's understanding --- for example, elaborated type
/// specifiers. If this is all the sugar we see, we don't want an
/// a.k.a. clause.
/// 2) Some types are technically sugared but are much more familiar
/// when seen in their sugared form --- for example, va_list,
/// vector types, and the magic Objective C types. We don't
/// want to desugar these, even if we do produce an a.k.a. clause.
/// 3) Some types may have already been desugared previously in this diagnostic.
/// if this is the case, doing another "aka" would just be clutter.
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
/// 4) Two different types within the same diagnostic have the same output
/// string. In this case, force an a.k.a with the desugared type when
/// doing so will provide additional information.
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
///
/// \param Context the context in which the type was allocated
/// \param Ty the type to print
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
/// \param QualTypeVals pointer values to QualTypes which are used in the
/// diagnostic message
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
static std::string
ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty,
Use ArrayRef in some function parameters instead of a pointer and count. No functional change. llvm-svn: 210750
2014-06-12 05:32:27 +00:00
ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
ArrayRef<intptr_t> QualTypeVals) {
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
// FIXME: Playing with std::string is really slow.
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
bool ForceAKA = false;
QualType CanTy = Ty.getCanonicalType();
When 'bool' is not a built-in type but is defined as a macro, print 'bool' rather than '_Bool' within types, to make things a bit more readable. Fixes <rdar://problem/10063263>. llvm-svn: 140650
2011-09-27 22:38:19 +00:00
std::string S = Ty.getAsString(Context.getPrintingPolicy());
std::string CanS = CanTy.getAsString(Context.getPrintingPolicy());
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
[NFC] Use range based loop. Signed-off-by: Jun Zhang <jun@junz.org> Differential Revision: https://reviews.llvm.org/D122657
2022-03-29 15:24:48 +08:00
for (const intptr_t &QualTypeVal : QualTypeVals) {
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
QualType CompareTy =
[NFC] Use range based loop. Signed-off-by: Jun Zhang <jun@junz.org> Differential Revision: https://reviews.llvm.org/D122657
2022-03-29 15:24:48 +08:00
QualType::getFromOpaquePtr(reinterpret_cast<void *>(QualTypeVal));
Support for raw and template forms of numeric user-defined literals, and lots of tidying up. llvm-svn: 152392
2012-03-09 08:00:36 +00:00
if (CompareTy.isNull())
continue;
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
if (CompareTy == Ty)
continue; // Same types
QualType CompareCanTy = CompareTy.getCanonicalType();
if (CompareCanTy == CanTy)
continue; // Same canonical types
When 'bool' is not a built-in type but is defined as a macro, print 'bool' rather than '_Bool' within types, to make things a bit more readable. Fixes <rdar://problem/10063263>. llvm-svn: 140650
2011-09-27 22:38:19 +00:00
std::string CompareS = CompareTy.getAsString(Context.getPrintingPolicy());
AST: Avoid reading an unitialized value Desugar doesn't necessarily initialize ShouldAKA, but as of r241542 it may read it. Fix the misuse of the API and initialize this before passing it in. Found by ubsan. llvm-svn: 241705
2015-07-08 18:32:26 +00:00
bool ShouldAKA = false;
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
QualType CompareDesugar =
desugarForDiagnostic(Context, CompareTy, ShouldAKA);
Change the checks in the type aka printing. A confusing case where the string of the first type is the same as the aka string of the second type, but both types are different. Update the logic to print an aka for the first type to show that they are different. llvm-svn: 144558
2011-11-14 19:39:25 +00:00
std::string CompareDesugarStr =
CompareDesugar.getAsString(Context.getPrintingPolicy());
if (CompareS != S && CompareDesugarStr != S)
continue; // The type string is different than the comparison string
// and the desugared comparison string.
std::string CompareCanS =
CompareCanTy.getAsString(Context.getPrintingPolicy());
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
if (CompareCanS == CanS)
continue; // No new info from canonical type
ForceAKA = true;
break;
}
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
// Check to see if we already desugared this type in this
// diagnostic. If so, don't do it again.
bool Repeated = false;
[NFC] Use range based loop. Signed-off-by: Jun Zhang <jun@junz.org> Differential Revision: https://reviews.llvm.org/D122657
2022-03-29 15:24:48 +08:00
for (const auto &PrevArg : PrevArgs) {
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
// TODO: Handle ak_declcontext case.
[NFC] Use range based loop. Signed-off-by: Jun Zhang <jun@junz.org> Differential Revision: https://reviews.llvm.org/D122657
2022-03-29 15:24:48 +08:00
if (PrevArg.first == DiagnosticsEngine::ak_qualtype) {
QualType PrevTy(
QualType::getFromOpaquePtr(reinterpret_cast<void *>(PrevArg.second)));
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
if (PrevTy == Ty) {
Repeated = true;
break;
}
}
}
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
// Consider producing an a.k.a. clause if removing all the direct
// sugar gives us something "significantly different".
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
if (!Repeated) {
bool ShouldAKA = false;
[clangd] Add desugared type to hover Add desugared type to hover when the desugared type and the pretty-printed type are different. ```c++ template<typename T> struct TestHover { using Type = T; }; int main() { TestHover<int>::Type a; } ``` ``` variable a Type: TestHover<int>::Type (aka int) ``` Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D114522
2021-12-08 12:31:00 +08:00
QualType DesugaredTy = desugarForDiagnostic(Context, Ty, ShouldAKA);
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
if (ShouldAKA || ForceAKA) {
if (DesugaredTy == Ty) {
DesugaredTy = Ty.getCanonicalType();
}
When 'bool' is not a built-in type but is defined as a macro, print 'bool' rather than '_Bool' within types, to make things a bit more readable. Fixes <rdar://problem/10063263>. llvm-svn: 140650
2011-09-27 22:38:19 +00:00
std::string akaStr = DesugaredTy.getAsString(Context.getPrintingPolicy());
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
if (akaStr != S) {
S = "'" + S + "' (aka '" + akaStr + "')";
return S;
}
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
}
Print detailed vector type information on diagnostics. We never aka vector types because our attributed syntax for it is less comprehensible than the typedefs. This leaves the user in the dark when the typedef isn't named that well. Example: v2s v; v4f w; w = v; The naming in this cases isn't even that bad, but the error we give is useless without looking up the actual typedefs. t.c:6:5: error: assigning to 'v4f' from incompatible type 'v2s' Now: t.c:6:5: error: assigning to 'v4f' (vector of 4 'float' values) from incompatible type 'v2s' (vector of 2 'int' values) We do this for all diagnostics that print a vector type. llvm-svn: 207267
2014-04-25 20:41:38 +00:00
// Give some additional info on vector types. These are either not desugared
// or displaying complex __attribute__ expressions so add details of the
// type and element count.
Merge isVectorType() and getAs<VectorType> calls to silence clang static analyzer warning. NFCI.
2020-01-13 14:54:02 +00:00
if (const auto *VTy = Ty->getAs<VectorType>()) {
Print detailed vector type information on diagnostics. We never aka vector types because our attributed syntax for it is less comprehensible than the typedefs. This leaves the user in the dark when the typedef isn't named that well. Example: v2s v; v4f w; w = v; The naming in this cases isn't even that bad, but the error we give is useless without looking up the actual typedefs. t.c:6:5: error: assigning to 'v4f' from incompatible type 'v2s' Now: t.c:6:5: error: assigning to 'v4f' (vector of 4 'float' values) from incompatible type 'v2s' (vector of 2 'int' values) We do this for all diagnostics that print a vector type. llvm-svn: 207267
2014-04-25 20:41:38 +00:00
std::string DecoratedString;
llvm::raw_string_ostream OS(DecoratedString);
const char *Values = VTy->getNumElements() > 1 ? "values" : "value";
OS << "'" << S << "' (vector of " << VTy->getNumElements() << " '"
<< VTy->getElementType().getAsString(Context.getPrintingPolicy())
<< "' " << Values << ")";
[NFC][AST] Return underlying strings directly instead of OS.str() This avoids an unnecessary copy required by 'return OS.str()', allowing instead for NRVO or implicit move. The .str() call (which flushes the stream) is no longer required since 65b13610a5226b84889b923bae884ba395ad084d, which made raw_string_ostream unbuffered by default. Differential Revision: https://reviews.llvm.org/D115374
2021-12-09 14:52:30 -08:00
return DecoratedString;
Print detailed vector type information on diagnostics. We never aka vector types because our attributed syntax for it is less comprehensible than the typedefs. This leaves the user in the dark when the typedef isn't named that well. Example: v2s v; v4f w; w = v; The naming in this cases isn't even that bad, but the error we give is useless without looking up the actual typedefs. t.c:6:5: error: assigning to 'v4f' from incompatible type 'v2s' Now: t.c:6:5: error: assigning to 'v4f' (vector of 4 'float' values) from incompatible type 'v2s' (vector of 2 'int' values) We do this for all diagnostics that print a vector type. llvm-svn: 207267
2014-04-25 20:41:38 +00:00
}
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
}
Teach the AKA calculation to look at sugar on the pointee type for pointers and references. This is a WIP as we should handle function pointers, etc. Reshuffle the code to do this to facilitate recursing in this manner, and to check for the type already being printed first rather than last. llvm-svn: 103712
2010-05-13 11:37:24 +00:00
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
S = "'" + S + "'";
return S;
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
static bool FormatTemplateTypeDiff(ASTContext &Context, QualType FromType,
QualType ToType, bool PrintTree,
bool PrintFromType, bool ElideType,
Push the raw_ostream through the template diffing code. llvm-svn: 175896
2013-02-22 16:08:12 +00:00
bool ShowColors, raw_ostream &OS);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
void clang::FormatASTNodeDiagnosticArgument(
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-25 23:23:43 +00:00
DiagnosticsEngine::ArgumentKind Kind,
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
intptr_t Val,
Use StringRef to simplify code. No functional change. llvm-svn: 210751
2014-06-12 05:32:35 +00:00
StringRef Modifier,
StringRef Argument,
Use ArrayRef in some function parameters instead of a pointer and count. No functional change. llvm-svn: 210750
2014-06-12 05:32:27 +00:00
ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 10:55:15 +00:00
SmallVectorImpl<char> &Output,
Apply patch from Richard Trieu to fix PR9548: When two different types has the same text representation in the same diagnostic message, print an a.k.a. after the type if the a.k.a. gives extra information about the type. class versa_string; typedef versa_string string; namespace std {template <typename T> class vector;} using std::vector; void f(vector<string> v); namespace std { class basic_string; typedef basic_string string; template <typename T> class vector {}; void g() { vector<string> v; f(v); } } Old message: ---------------- test.cc:15:3: error: no matching function for call to 'f' f(&v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' to 'vector<string>' for 1st argument void f(vector<string> v); ^ 1 error generated. New message: --------------- test.cc:15:3: error: no matching function for call to 'f' f(v); ^ test.cc:7:6: note: candidate function not viable: no known conversion from 'vector<string>' (aka 'std::vector<std::basic_string>') to 'vector<string>' (aka 'std::vector<versa_string>') for 1st argument void f(vector<string> v); ^ 1 error generated. llvm-svn: 134904
2011-07-11 17:49:21 +00:00
void *Cookie,
More ArrayRef-ification of methods. llvm-svn: 151152
2012-02-22 09:51:33 +00:00
ArrayRef<intptr_t> QualTypeVals) {
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
ASTContext &Context = *static_cast<ASTContext*>(Cookie);
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
size_t OldEnd = Output.size();
llvm::raw_svector_ostream OS(Output);
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
bool NeedQuotes = true;
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
switch (Kind) {
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 05:06:16 +00:00
default: llvm_unreachable("unknown ArgumentKind");
[Sema] Improve diagnostic about addr spaces for overload candidates Allow sending address spaces into diagnostics to simplify and improve error reporting. Improved wording of diagnostics for address spaces in overloading. Tags: #clang Differential Revision: https://reviews.llvm.org/D71111
2019-12-13 12:30:59 +00:00
case DiagnosticsEngine::ak_addrspace: {
assert(Modifier.empty() && Argument.empty() &&
[AST] Fix typo in assert messages Differential Revision: https://reviews.llvm.org/D120221
2022-03-08 11:06:18 +00:00
"Invalid modifier for Qualifiers argument");
[Sema] Improve diagnostic about addr spaces for overload candidates Allow sending address spaces into diagnostics to simplify and improve error reporting. Improved wording of diagnostics for address spaces in overloading. Tags: #clang Differential Revision: https://reviews.llvm.org/D71111
2019-12-13 12:30:59 +00:00
auto S = Qualifiers::getAddrSpaceAsString(static_cast<LangAS>(Val));
if (S.empty()) {
OS << (Context.getLangOpts().OpenCL ? "default" : "generic");
OS << " address space";
} else {
OS << "address space";
OS << " '" << S << "'";
}
NeedQuotes = false;
break;
}
[Basic] Extend DiagnosticEngine to store and format Qualifiers. Qualifiers can now be streamed into the DiagnosticEngine using regular << operator. If Qualifiers are empty 'unqualified' will be printed in the diagnostic otherwise regular qual syntax is used. Differential Revision: https://reviews.llvm.org/D56198 llvm-svn: 350386
2019-01-04 11:50:36 +00:00
case DiagnosticsEngine::ak_qual: {
assert(Modifier.empty() && Argument.empty() &&
[AST] Fix typo in assert messages Differential Revision: https://reviews.llvm.org/D120221
2022-03-08 11:06:18 +00:00
"Invalid modifier for Qualifiers argument");
[Basic] Extend DiagnosticEngine to store and format Qualifiers. Qualifiers can now be streamed into the DiagnosticEngine using regular << operator. If Qualifiers are empty 'unqualified' will be printed in the diagnostic otherwise regular qual syntax is used. Differential Revision: https://reviews.llvm.org/D56198 llvm-svn: 350386
2019-01-04 11:50:36 +00:00
Qualifiers Q(Qualifiers::fromOpaqueValue(Val));
auto S = Q.getAsString();
if (S.empty()) {
OS << "unqualified";
NeedQuotes = false;
} else {
[Sema] Improve diagnostic about addr spaces for overload candidates Allow sending address spaces into diagnostics to simplify and improve error reporting. Improved wording of diagnostics for address spaces in overloading. Tags: #clang Differential Revision: https://reviews.llvm.org/D71111
2019-12-13 12:30:59 +00:00
OS << S;
[Basic] Extend DiagnosticEngine to store and format Qualifiers. Qualifiers can now be streamed into the DiagnosticEngine using regular << operator. If Qualifiers are empty 'unqualified' will be printed in the diagnostic otherwise regular qual syntax is used. Differential Revision: https://reviews.llvm.org/D56198 llvm-svn: 350386
2019-01-04 11:50:36 +00:00
}
break;
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
case DiagnosticsEngine::ak_qualtype_pair: {
Properly update the FormattedArgs vector when the template type diffing falls back to regular type printing. llvm-svn: 159976
2012-07-10 01:46:04 +00:00
TemplateDiffTypes &TDT = *reinterpret_cast<TemplateDiffTypes*>(Val);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
QualType FromType =
QualType::getFromOpaquePtr(reinterpret_cast<void*>(TDT.FromType));
QualType ToType =
QualType::getFromOpaquePtr(reinterpret_cast<void*>(TDT.ToType));
if (FormatTemplateTypeDiff(Context, FromType, ToType, TDT.PrintTree,
TDT.PrintFromType, TDT.ElideType,
Push the raw_ostream through the template diffing code. llvm-svn: 175896
2013-02-22 16:08:12 +00:00
TDT.ShowColors, OS)) {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
NeedQuotes = !TDT.PrintTree;
Properly update the FormattedArgs vector when the template type diffing falls back to regular type printing. llvm-svn: 159976
2012-07-10 01:46:04 +00:00
TDT.TemplateDiffUsed = true;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
break;
}
// Don't fall-back during tree printing. The caller will handle
// this case.
if (TDT.PrintTree)
return;
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
// Attempting to do a template diff on non-templates. Set the variables
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
// and continue with regular type printing of the appropriate type.
Val = TDT.PrintFromType ? TDT.FromType : TDT.ToType;
Use StringRef to simplify code. No functional change. llvm-svn: 210751
2014-06-12 05:32:35 +00:00
Modifier = StringRef();
Argument = StringRef();
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
// Fall through
[clang] LLVM_FALLTHROUGH => [[fallthrough]]. NFC With C++17 there is no Clang pedantic warning or MSVC C5051. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D131346
2022-08-08 09:12:46 -07:00
[[fallthrough]];
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-25 23:23:43 +00:00
case DiagnosticsEngine::ak_qualtype: {
Use StringRef to simplify code. No functional change. llvm-svn: 210751
2014-06-12 05:32:35 +00:00
assert(Modifier.empty() && Argument.empty() &&
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
"Invalid modifier for QualType argument");
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
QualType Ty(QualType::getFromOpaquePtr(reinterpret_cast<void*>(Val)));
Use ArrayRef in some function parameters instead of a pointer and count. No functional change. llvm-svn: 210750
2014-06-12 05:32:27 +00:00
OS << ConvertTypeToDiagnosticString(Context, Ty, PrevArgs, QualTypeVals);
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
NeedQuotes = false;
break;
}
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-25 23:23:43 +00:00
case DiagnosticsEngine::ak_declarationname: {
Use StringRef to simplify code. No functional change. llvm-svn: 210751
2014-06-12 05:32:35 +00:00
if (Modifier == "objcclass" && Argument.empty())
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
OS << '+';
Use StringRef to simplify code. No functional change. llvm-svn: 210751
2014-06-12 05:32:35 +00:00
else if (Modifier == "objcinstance" && Argument.empty())
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
OS << '-';
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
else
Use StringRef to simplify code. No functional change. llvm-svn: 210751
2014-06-12 05:32:35 +00:00
assert(Modifier.empty() && Argument.empty() &&
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
"Invalid modifier for DeclarationName argument");
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
Provide operator<< for stream output of DeclarationNames ASTDumper was already trying to do this & instead got an implicit bool conversion by surprise (thus printing out 0 or 1 instead of the name of the declaration). To avoid that issue & simplify call sites, simply make it the normal/expected operator<<(raw_ostream&, ...) overload & simplify all the existing call sites. (bonus: this function doesn't need to be a member or friend, it's just using public API in DeclarationName) llvm-svn: 181832
2013-05-14 21:04:00 +00:00
OS << DeclarationName::getFromOpaqueInteger(Val);
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
break;
}
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-25 23:23:43 +00:00
case DiagnosticsEngine::ak_nameddecl: {
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
bool Qualified;
Use StringRef to simplify code. No functional change. llvm-svn: 210751
2014-06-12 05:32:35 +00:00
if (Modifier == "q" && Argument.empty())
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
Qualified = true;
else {
Use StringRef to simplify code. No functional change. llvm-svn: 210751
2014-06-12 05:32:35 +00:00
assert(Modifier.empty() && Argument.empty() &&
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
"Invalid modifier for NamedDecl* argument");
Qualified = false;
}
Improve the diagnostic text for -Wmissing-noreturn to include the name of the function in question when applicable (that is, not for blocks). Patch by Joerg Sonnenberger with some stylistic tweaks by me. When discussing this weth Joerg, streaming the decl directly into the diagnostic didn't work because we have a pointer-to-const, and the overload doesn't accept such. In order to make my style tweaks to the patch, I first changed the overload to accept a pointer-to-const, and then changed the diagnostic printing layer to also use a pointer-to-const, cleaning up a gross line of code along the way. llvm-svn: 138854
2011-08-31 09:01:53 +00:00
const NamedDecl *ND = reinterpret_cast<const NamedDecl*>(Val);
Streamify getNameForDiagnostic and remove the string versions of PrintTemplateArgumentList. llvm-svn: 175894
2013-02-22 15:46:01 +00:00
ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), Qualified);
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
break;
}
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-25 23:23:43 +00:00
case DiagnosticsEngine::ak_nestednamespec: {
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
NestedNameSpecifier *NNS = reinterpret_cast<NestedNameSpecifier*>(Val);
[clang] NNS: don't print trailing scope resolution operator in diagnostics (#130529) This clears up the printing of a NestedNameSpecifier so a trailing '::' is not printed, unless it refers into the global scope. This fixes a bunch of diagnostics where the trailing :: was awkward. This also prints the NNS quoted consistenty. There is a drive-by improvement to error recovery, where now we print the actual type instead of `<dependent type>`. This will clear up further uses of NNS printing in further patches.
2025-03-10 09:37:38 -03:00
NNS->print(OS, Context.getPrintingPolicy(),
/*ResolveTemplateArguments=*/false,
/*PrintFinalScopeResOp=*/false);
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
break;
}
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-25 23:23:43 +00:00
case DiagnosticsEngine::ak_declcontext: {
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
DeclContext *DC = reinterpret_cast<DeclContext *> (Val);
assert(DC && "Should never have a null declaration context");
Implement -Wframe-larger-than backend diagnostic Add driver and frontend support for the GCC -Wframe-larger-than=bytes warning. This is the first GCC-compatible backend diagnostic built around LLVM's reporting feature. This commit adds infrastructure to perform reverse lookup from mangled names emitted after LLVM IR generation. We use that to resolve precise locations and originating AST functions, lambdas or block declarations to produce seamless codegen-guided diagnostics. An associated change, StringMap now maintains unique mangled name strings instead of allocating copies. This is a net memory saving in C++ and a small hit for C where we no longer reuse IdentifierInfo storage, pending further optimisation. llvm-svn: 210293
2014-06-05 22:10:59 +00:00
NeedQuotes = false;
Refactor the diagnostic DeclContext printing. No functionality change. llvm-svn: 216517
2014-08-27 03:05:19 +00:00
// FIXME: Get the strings for DeclContext from some localized place
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
if (DC->isTranslationUnit()) {
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 07:00:24 +00:00
if (Context.getLangOpts().CPlusPlus)
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
OS << "the global namespace";
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
else
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
OS << "the global scope";
Refactor the diagnostic DeclContext printing. No functionality change. llvm-svn: 216517
2014-08-27 03:05:19 +00:00
} else if (DC->isClosure()) {
OS << "block literal";
} else if (isLambdaCallOperator(DC)) {
OS << "lambda expression";
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
} else if (TypeDecl *Type = dyn_cast<TypeDecl>(DC)) {
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
OS << ConvertTypeToDiagnosticString(Context,
Context.getTypeDeclType(Type),
Use ArrayRef in some function parameters instead of a pointer and count. No functional change. llvm-svn: 210750
2014-06-12 05:32:27 +00:00
PrevArgs, QualTypeVals);
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
} else {
Refactor the diagnostic DeclContext printing. No functionality change. llvm-svn: 216517
2014-08-27 03:05:19 +00:00
assert(isa<NamedDecl>(DC) && "Expected a NamedDecl");
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
NamedDecl *ND = cast<NamedDecl>(DC);
if (isa<NamespaceDecl>(ND))
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
OS << "namespace ";
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
else if (isa<ObjCMethodDecl>(ND))
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
OS << "method ";
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
else if (isa<FunctionDecl>(ND))
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
OS << "function ";
OS << '\'';
ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), true);
OS << '\'';
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
}
break;
}
Normalize line endings Some files had CRLF line terminators, some only had a mixture of CRLF and LF. Switch to LF. llvm-svn: 202659
2014-03-02 18:46:05 +00:00
case DiagnosticsEngine::ak_attr: {
const Attr *At = reinterpret_cast<Attr *>(Val);
assert(At && "Received null Attr object!");
OS << '\'' << At->getSpelling() << '\'';
NeedQuotes = false;
break;
}
[clang] fix diagnostic printing of expressions ignoring LangOpts (#134693) Currently when printing a template argument of expression type, the expression is converted immediately into a string to be sent to the diagnostic engine, unsing a fake LangOpts. This makes the expression printing look incorrect for the current language, besides being inneficient, as we don't actually need to print the expression if the diagnostic would be ignored. This fixes a nastiness with the TemplateArgument constructor for expressions being implicit, and all current users just passing an expression to a diagnostic were implicitly going through the template argument path. The expressions are also being printed unquoted. This will be fixed in a subsequent patch, as the test churn is much larger.
2025-04-07 23:19:32 -03:00
case DiagnosticsEngine::ak_expr: {
const Expr *E = reinterpret_cast<Expr *>(Val);
assert(E && "Received null Expr!");
E->printPretty(OS, /*Helper=*/nullptr, Context.getPrintingPolicy());
break;
}
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
}
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
if (NeedQuotes) {
Output.insert(Output.begin()+OldEnd, '\'');
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
Output.push_back('\'');
Streamify FormatASTNodeDiagnosticArgument. llvm-svn: 175895
2013-02-22 15:46:08 +00:00
}
Move the diagnostic argument formatting function out of Sema and make it available within the AST library, of which Sema is one client. No functionality change. llvm-svn: 95701
2010-02-09 22:26:47 +00:00
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// TemplateDiff - A class that constructs a pretty string for a pair of
/// QualTypes. For the pair of types, a diff tree will be created containing
/// all the information about the templates and template arguments. Afterwards,
/// the tree is transformed to a string according to the options passed in.
namespace {
class TemplateDiff {
/// Context - The ASTContext which is used for comparing template arguments.
ASTContext &Context;
/// Policy - Used during expression printing.
PrintingPolicy Policy;
/// ElideType - Option to elide identical types.
bool ElideType;
/// PrintTree - Format output string as a tree.
bool PrintTree;
/// ShowColor - Diagnostics support color, so bolding will be used.
bool ShowColor;
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 05:48:38 +00:00
/// FromTemplateType - When single type printing is selected, this is the
Fix duplicate word typos; NFC This revision fixes typos where there are 2 consecutive words which are duplicated. There should be no code changes in this revision (only changes to comments and docs). Do let me know if there are any undesirable changes in this revision. Thanks.
2022-11-08 07:21:23 -05:00
/// type to be printed. When tree printing is selected, this type will
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 05:48:38 +00:00
/// show up first in the tree.
QualType FromTemplateType;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 05:48:38 +00:00
/// ToTemplateType - The type that FromType is compared to. Only in tree
/// printing will this type be outputed.
QualType ToTemplateType;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// OS - The stream used to construct the output strings.
Push the raw_ostream through the template diffing code. llvm-svn: 175896
2013-02-22 16:08:12 +00:00
raw_ostream &OS;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// IsBold - Keeps track of the bold formatting for the output string.
bool IsBold;
/// DiffTree - A tree representation the differences between two types.
class DiffTree {
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
public:
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// DiffKind - The difference in a DiffNode. Fields of
/// TemplateArgumentInfo needed by each difference can be found in the
/// Set* and Get* functions.
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
enum DiffKind {
/// Incomplete or invalid node.
Invalid,
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 00:36:59 +00:00
/// Another level of templates
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
Template,
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// Type difference, all type differences except those falling under
/// the Template difference.
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
Type,
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// Expression difference, this is only when both arguments are
/// expressions. If one argument is an expression and the other is
/// Integer or Declaration, then use that diff type instead.
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
Expression,
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// Template argument difference
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
TemplateTemplate,
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// Integer difference
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
Integer,
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// Declaration difference, nullptr arguments are included here
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 05:01:53 +00:00
Declaration,
/// One argument being integer and the other being declaration
FromIntegerAndToDeclaration,
FromDeclarationAndToInteger
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
};
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
private:
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// TemplateArgumentInfo - All the information needed to pretty print
/// a template argument. See the Set* and Get* functions to see which
/// fields are used for each DiffKind.
struct TemplateArgumentInfo {
QualType ArgType;
Qualifiers Qual;
llvm::APSInt Val;
bool IsValidInt = false;
Expr *ArgExpr = nullptr;
TemplateDecl *TD = nullptr;
ValueDecl *VD = nullptr;
bool NeedAddressOf = false;
bool IsNullPtr = false;
bool IsDefault = false;
};
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// DiffNode - The root node stores the original type. Each child node
/// stores template arguments of their parents. For templated types, the
/// template decl is also stored.
struct DiffNode {
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
DiffKind Kind = Invalid;
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// NextNode - The index of the next sibling node or 0.
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
unsigned NextNode = 0;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// ChildNode - The index of the first child node or 0.
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
unsigned ChildNode = 0;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// ParentNode - The index of the parent node.
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
unsigned ParentNode = 0;
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
TemplateArgumentInfo FromArgInfo, ToArgInfo;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// Same - Whether the two arguments evaluate to the same value.
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
bool Same = false;
DiffNode(unsigned ParentNode = 0) : ParentNode(ParentNode) {}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
};
/// FlatTree - A flattened tree used to store the DiffNodes.
Remove useless 'llvm::' qualifier from names like StringRef and others that are brought into 'clang' namespace by clang/Basic/LLVM.h llvm-svn: 172323
2013-01-12 19:30:44 +00:00
SmallVector<DiffNode, 16> FlatTree;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// CurrentNode - The index of the current node being used.
unsigned CurrentNode;
/// NextFreeNode - The index of the next unused node. Used when creating
/// child nodes.
unsigned NextFreeNode;
/// ReadNode - The index of the current node being read.
unsigned ReadNode;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
public:
Fix cppcheck uninitialized variable in DiffTree() constructor warning. NFCI.
2020-01-13 14:55:51 +00:00
DiffTree() : CurrentNode(0), NextFreeNode(1), ReadNode(0) {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
FlatTree.push_back(DiffNode());
}
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
// Node writing functions, one for each valid DiffKind element.
void SetTemplateDiff(TemplateDecl *FromTD, TemplateDecl *ToTD,
Qualifiers FromQual, Qualifiers ToQual,
bool FromDefault, bool ToDefault) {
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
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);
}
void SetTypeDiff(QualType FromType, QualType ToType, bool FromDefault,
bool ToDefault) {
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
FlatTree[CurrentNode].Kind = Type;
FlatTree[CurrentNode].FromArgInfo.ArgType = FromType;
FlatTree[CurrentNode].ToArgInfo.ArgType = ToType;
SetDefault(FromDefault, ToDefault);
}
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
void SetExpressionDiff(Expr *FromExpr, Expr *ToExpr, bool FromDefault,
bool ToDefault) {
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
FlatTree[CurrentNode].Kind = Expression;
FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
SetDefault(FromDefault, ToDefault);
}
void SetTemplateTemplateDiff(TemplateDecl *FromTD, TemplateDecl *ToTD,
bool FromDefault, bool ToDefault) {
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
FlatTree[CurrentNode].Kind = TemplateTemplate;
FlatTree[CurrentNode].FromArgInfo.TD = FromTD;
FlatTree[CurrentNode].ToArgInfo.TD = ToTD;
SetDefault(FromDefault, ToDefault);
}
Apply some suggestions from clang-tidy's performance-unnecessary-value-param. No functionality change intended. llvm-svn: 272789
2016-06-15 14:20:56 +00:00
void SetIntegerDiff(const llvm::APSInt &FromInt, const llvm::APSInt &ToInt,
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
bool IsValidFromInt, bool IsValidToInt,
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
QualType FromIntType, QualType ToIntType,
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
Expr *FromExpr, Expr *ToExpr, bool FromDefault,
bool ToDefault) {
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
FlatTree[CurrentNode].Kind = Integer;
FlatTree[CurrentNode].FromArgInfo.Val = FromInt;
FlatTree[CurrentNode].ToArgInfo.Val = ToInt;
FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;
FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;
FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
SetDefault(FromDefault, ToDefault);
}
void SetDeclarationDiff(ValueDecl *FromValueDecl, ValueDecl *ToValueDecl,
bool FromAddressOf, bool ToAddressOf,
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
bool FromNullPtr, bool ToNullPtr, Expr *FromExpr,
Expr *ToExpr, bool FromDefault, bool ToDefault) {
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
FlatTree[CurrentNode].Kind = Declaration;
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;
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;
FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
SetDefault(FromDefault, ToDefault);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 05:01:53 +00:00
void SetFromDeclarationAndToIntegerDiff(
ValueDecl *FromValueDecl, bool FromAddressOf, bool FromNullPtr,
Apply some suggestions from clang-tidy's performance-unnecessary-value-param. No functionality change intended. llvm-svn: 272789
2016-06-15 14:20:56 +00:00
Expr *FromExpr, const llvm::APSInt &ToInt, bool IsValidToInt,
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 05:01:53 +00:00
QualType ToIntType, Expr *ToExpr, bool FromDefault, bool ToDefault) {
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
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);
}
void SetFromIntegerAndToDeclarationDiff(
Apply some suggestions from clang-tidy's performance-unnecessary-value-param. No functionality change intended. llvm-svn: 272789
2016-06-15 14:20:56 +00:00
const llvm::APSInt &FromInt, bool IsValidFromInt, QualType FromIntType,
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 05:01:53 +00:00
Expr *FromExpr, ValueDecl *ToValueDecl, bool ToAddressOf,
bool ToNullPtr, Expr *ToExpr, bool FromDefault, bool ToDefault) {
assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
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);
}
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// SetDefault - Sets FromDefault and ToDefault flags of the current node.
void SetDefault(bool FromDefault, bool ToDefault) {
Fix a -Wparentheses warning in ASTDiagnostic.cpp. llvm-svn: 257871
2016-01-15 05:57:41 +00:00
assert((!FromDefault || !ToDefault) && "Both arguments cannot be default.");
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
FlatTree[CurrentNode].FromArgInfo.IsDefault = FromDefault;
FlatTree[CurrentNode].ToArgInfo.IsDefault = ToDefault;
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// SetSame - Sets the same flag of the current node.
void SetSame(bool Same) {
FlatTree[CurrentNode].Same = Same;
}
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
/// SetKind - Sets the current node's type.
void SetKind(DiffKind Kind) {
FlatTree[CurrentNode].Kind = Kind;
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// Up - Changes the node to the parent of the current node.
void Up() {
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 05:48:38 +00:00
assert(FlatTree[CurrentNode].Kind != Invalid &&
"Cannot exit node before setting node information.");
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
CurrentNode = FlatTree[CurrentNode].ParentNode;
}
/// AddNode - Adds a child node to the current node, then sets that node
/// node as the current node.
void AddNode() {
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 05:48:38 +00:00
assert(FlatTree[CurrentNode].Kind == Template &&
"Only Template nodes can have children nodes.");
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
FlatTree.push_back(DiffNode(CurrentNode));
DiffNode &Node = FlatTree[CurrentNode];
if (Node.ChildNode == 0) {
// If a child node doesn't exist, add one.
Node.ChildNode = NextFreeNode;
} else {
// If a child node exists, find the last child node and add a
// next node to it.
unsigned i;
for (i = Node.ChildNode; FlatTree[i].NextNode != 0;
i = FlatTree[i].NextNode) {
}
FlatTree[i].NextNode = NextFreeNode;
}
CurrentNode = NextFreeNode;
++NextFreeNode;
}
// Node reading functions.
/// StartTraverse - Prepares the tree for recursive traversal.
void StartTraverse() {
ReadNode = 0;
CurrentNode = NextFreeNode;
NextFreeNode = 0;
}
/// Parent - Move the current read node to its parent.
void Parent() {
ReadNode = FlatTree[ReadNode].ParentNode;
}
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
void GetTemplateDiff(TemplateDecl *&FromTD, TemplateDecl *&ToTD,
Qualifiers &FromQual, Qualifiers &ToQual) {
assert(FlatTree[ReadNode].Kind == Template && "Unexpected kind.");
FromTD = FlatTree[ReadNode].FromArgInfo.TD;
ToTD = FlatTree[ReadNode].ToArgInfo.TD;
FromQual = FlatTree[ReadNode].FromArgInfo.Qual;
ToQual = FlatTree[ReadNode].ToArgInfo.Qual;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
void GetTypeDiff(QualType &FromType, QualType &ToType) {
assert(FlatTree[ReadNode].Kind == Type && "Unexpected kind");
FromType = FlatTree[ReadNode].FromArgInfo.ArgType;
ToType = FlatTree[ReadNode].ToArgInfo.ArgType;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
void GetExpressionDiff(Expr *&FromExpr, Expr *&ToExpr) {
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
assert(FlatTree[ReadNode].Kind == Expression && "Unexpected kind");
FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
void GetTemplateTemplateDiff(TemplateDecl *&FromTD, TemplateDecl *&ToTD) {
assert(FlatTree[ReadNode].Kind == TemplateTemplate && "Unexpected kind.");
FromTD = FlatTree[ReadNode].FromArgInfo.TD;
ToTD = FlatTree[ReadNode].ToArgInfo.TD;
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-01 21:29:28 +00:00
}
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
void GetIntegerDiff(llvm::APSInt &FromInt, llvm::APSInt &ToInt,
bool &IsValidFromInt, bool &IsValidToInt,
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
QualType &FromIntType, QualType &ToIntType,
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
Expr *&FromExpr, Expr *&ToExpr) {
assert(FlatTree[ReadNode].Kind == Integer && "Unexpected kind.");
FromInt = FlatTree[ReadNode].FromArgInfo.Val;
ToInt = FlatTree[ReadNode].ToArgInfo.Val;
IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;
IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;
ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-28 20:32:51 +00:00
}
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
void GetDeclarationDiff(ValueDecl *&FromValueDecl, ValueDecl *&ToValueDecl,
bool &FromAddressOf, bool &ToAddressOf,
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
bool &FromNullPtr, bool &ToNullPtr, Expr *&FromExpr,
Expr *&ToExpr) {
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
assert(FlatTree[ReadNode].Kind == Declaration && "Unexpected kind.");
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;
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;
ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
}
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 05:01:53 +00:00
void GetFromDeclarationAndToIntegerDiff(
ValueDecl *&FromValueDecl, bool &FromAddressOf, bool &FromNullPtr,
Expr *&FromExpr, llvm::APSInt &ToInt, bool &IsValidToInt,
QualType &ToIntType, Expr *&ToExpr) {
assert(FlatTree[ReadNode].Kind == FromDeclarationAndToInteger &&
"Unexpected kind.");
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;
}
void GetFromIntegerAndToDeclarationDiff(
llvm::APSInt &FromInt, bool &IsValidFromInt, QualType &FromIntType,
Expr *&FromExpr, ValueDecl *&ToValueDecl, bool &ToAddressOf,
bool &ToNullPtr, Expr *&ToExpr) {
assert(FlatTree[ReadNode].Kind == FromIntegerAndToDeclaration &&
"Unexpected kind.");
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;
}
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// FromDefault - Return true if the from argument is the default.
bool FromDefault() {
return FlatTree[ReadNode].FromArgInfo.IsDefault;
}
/// ToDefault - Return true if the to argument is the default.
bool ToDefault() {
return FlatTree[ReadNode].ToArgInfo.IsDefault;
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// NodeIsSame - Returns true the arguments are the same.
bool NodeIsSame() {
return FlatTree[ReadNode].Same;
}
/// HasChildrend - Returns true if the node has children.
bool HasChildren() {
return FlatTree[ReadNode].ChildNode != 0;
}
/// MoveToChild - Moves from the current node to its child.
void MoveToChild() {
ReadNode = FlatTree[ReadNode].ChildNode;
}
/// AdvanceSibling - If there is a next sibling, advance to it and return
/// true. Otherwise, return false.
bool AdvanceSibling() {
if (FlatTree[ReadNode].NextNode == 0)
return false;
ReadNode = FlatTree[ReadNode].NextNode;
return true;
}
/// HasNextSibling - Return true if the node has a next sibling.
bool HasNextSibling() {
return FlatTree[ReadNode].NextNode != 0;
}
/// Empty - Returns true if the tree has no information.
bool Empty() {
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
return GetKind() == Invalid;
}
/// GetKind - Returns the current node's type.
DiffKind GetKind() {
return FlatTree[ReadNode].Kind;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
};
DiffTree Tree;
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// TSTiterator - a pair of iterators that walks the
/// TemplateSpecializationType and the desugared TemplateSpecializationType.
/// The deseguared TemplateArgument should provide the canonical argument
/// for comparisons.
class TSTiterator {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
typedef const TemplateArgument& reference;
typedef const TemplateArgument* pointer;
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// InternalIterator - an iterator that is used to enter a
/// TemplateSpecializationType and read TemplateArguments inside template
/// parameter packs in order with the rest of the TemplateArguments.
struct InternalIterator {
/// TST - the template specialization whose arguments this iterator
/// traverse over.
const TemplateSpecializationType *TST;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// Index - the index of the template argument in TST.
unsigned Index;
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// CurrentTA - if CurrentTA is not the same as EndTA, then CurrentTA
/// points to a TemplateArgument within a parameter pack.
TemplateArgument::pack_iterator CurrentTA;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// EndTA - the end iterator of a parameter pack
TemplateArgument::pack_iterator EndTA;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// InternalIterator - Constructs an iterator and sets it to the first
/// template argument.
InternalIterator(const TemplateSpecializationType *TST)
: TST(TST), Index(0), CurrentTA(nullptr), EndTA(nullptr) {
Fix crash in template type diffing. When the type being diffed is a type alias, and the orginal type is not a templated type, then there will be no unsugared TemplateSpecializationType. When this happens, exit early from the constructor. Also add assertions to the other iterator accessor to prevent the iterator from being used. llvm-svn: 277797
2016-08-05 03:16:36 +00:00
if (!TST) return;
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
if (isEnd()) return;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
// Set to first template argument. If not a parameter pack, done.
NFC: [clang] Template argument cleanups. Removes a bunch of obsolete methods in favor of a single one returning an ArrayRef of TemplateArgument. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D136602
2022-10-24 14:18:46 +02:00
TemplateArgument TA = TST->template_arguments()[0];
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
if (TA.getKind() != TemplateArgument::Pack) return;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
// Start looking into the parameter pack.
CurrentTA = TA.pack_begin();
EndTA = TA.pack_end();
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
// Found a valid template argument.
if (CurrentTA != EndTA) return;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
// Parameter pack is empty, use the increment to get to a valid
// template argument.
++(*this);
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
PR30831: Teach template type diffing to cope with TemplateSpecializationTypes that desugar to non-TSTs (such as injected-class-names). llvm-svn: 285437
2016-10-28 19:54:43 +00:00
/// Return true if the iterator is non-singular.
bool isValid() const { return TST; }
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// isEnd - Returns true if the iterator is one past the end.
bool isEnd() const {
Fix typos from r277797 and unused variable from r277889. llvm-svn: 277900
2016-08-06 01:44:06 +00:00
assert(TST && "InternalIterator is invalid with a null TST.");
NFC: [clang] Template argument cleanups. Removes a bunch of obsolete methods in favor of a single one returning an ArrayRef of TemplateArgument. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D136602
2022-10-24 14:18:46 +02:00
return Index >= TST->template_arguments().size();
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// &operator++ - Increment the iterator to the next template argument.
InternalIterator &operator++() {
Fix typos from r277797 and unused variable from r277889. llvm-svn: 277900
2016-08-06 01:44:06 +00:00
assert(TST && "InternalIterator is invalid with a null TST.");
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
if (isEnd()) {
return *this;
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
// If in a parameter pack, advance in the parameter pack.
if (CurrentTA != EndTA) {
++CurrentTA;
if (CurrentTA != EndTA)
return *this;
}
// Loop until a template argument is found, or the end is reached.
while (true) {
// Advance to the next template argument. Break if reached the end.
NFC: [clang] Template argument cleanups. Removes a bunch of obsolete methods in favor of a single one returning an ArrayRef of TemplateArgument. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D136602
2022-10-24 14:18:46 +02:00
if (++Index == TST->template_arguments().size())
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
break;
// If the TemplateArgument is not a parameter pack, done.
NFC: [clang] Template argument cleanups. Removes a bunch of obsolete methods in favor of a single one returning an ArrayRef of TemplateArgument. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D136602
2022-10-24 14:18:46 +02:00
TemplateArgument TA = TST->template_arguments()[Index];
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
if (TA.getKind() != TemplateArgument::Pack)
break;
// Handle parameter packs.
CurrentTA = TA.pack_begin();
EndTA = TA.pack_end();
// If the parameter pack is empty, try to advance again.
if (CurrentTA != EndTA)
break;
}
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
return *this;
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// operator* - Returns the appropriate TemplateArgument.
reference operator*() const {
Fix typos from r277797 and unused variable from r277889. llvm-svn: 277900
2016-08-06 01:44:06 +00:00
assert(TST && "InternalIterator is invalid with a null TST.");
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
assert(!isEnd() && "Index exceeds number of arguments.");
if (CurrentTA == EndTA)
NFC: [clang] Template argument cleanups. Removes a bunch of obsolete methods in favor of a single one returning an ArrayRef of TemplateArgument. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D136602
2022-10-24 14:18:46 +02:00
return TST->template_arguments()[Index];
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
else
return *CurrentTA;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// operator-> - Allow access to the underlying TemplateArgument.
pointer operator->() const {
Fix typos from r277797 and unused variable from r277889. llvm-svn: 277900
2016-08-06 01:44:06 +00:00
assert(TST && "InternalIterator is invalid with a null TST.");
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
return &operator*();
}
};
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
InternalIterator SugaredIterator;
InternalIterator DesugaredIterator;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
public:
TSTiterator(ASTContext &Context, const TemplateSpecializationType *TST)
PR30831: Teach template type diffing to cope with TemplateSpecializationTypes that desugar to non-TSTs (such as injected-class-names). llvm-svn: 285437
2016-10-28 19:54:43 +00:00
: SugaredIterator(TST),
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
DesugaredIterator(
PR30831: Teach template type diffing to cope with TemplateSpecializationTypes that desugar to non-TSTs (such as injected-class-names). llvm-svn: 285437
2016-10-28 19:54:43 +00:00
(TST->isSugared() && !TST->isTypeAlias())
? GetTemplateSpecializationType(Context, TST->desugar())
: nullptr) {}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// &operator++ - Increment the iterator to the next template argument.
TSTiterator &operator++() {
++SugaredIterator;
PR30831: Teach template type diffing to cope with TemplateSpecializationTypes that desugar to non-TSTs (such as injected-class-names). llvm-svn: 285437
2016-10-28 19:54:43 +00:00
if (DesugaredIterator.isValid())
Fix Clang crash with template type diffing. Fixes https://llvm.org/bugs/show_bug.cgi?id=27129 which is crash involving type aliases and template type diffing. Template arguments for type aliases and template arguments for the underlying desugared type may not have one-to-one relations, which could mess us the attempt to get more information from the desugared type. For type aliases, ignore the iterator over the desugared type. llvm-svn: 264940
2016-03-30 22:23:00 +00:00
++DesugaredIterator;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
return *this;
}
/// operator* - Returns the appropriate TemplateArgument.
reference operator*() const {
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
return *SugaredIterator;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
/// operator-> - Allow access to the underlying TemplateArgument.
pointer operator->() const {
return &operator*();
}
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
/// isEnd - Returns true if no more TemplateArguments are available.
bool isEnd() const {
return SugaredIterator.isEnd();
}
/// hasDesugaredTA - Returns true if there is another TemplateArgument
/// available.
bool hasDesugaredTA() const {
PR30831: Teach template type diffing to cope with TemplateSpecializationTypes that desugar to non-TSTs (such as injected-class-names). llvm-svn: 285437
2016-10-28 19:54:43 +00:00
return DesugaredIterator.isValid() && !DesugaredIterator.isEnd();
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
}
/// getDesugaredTA - Returns the desugared TemplateArgument.
reference getDesugaredTA() const {
PR30831: Teach template type diffing to cope with TemplateSpecializationTypes that desugar to non-TSTs (such as injected-class-names). llvm-svn: 285437
2016-10-28 19:54:43 +00:00
assert(DesugaredIterator.isValid() &&
Fix Clang crash with template type diffing. Fixes https://llvm.org/bugs/show_bug.cgi?id=27129 which is crash involving type aliases and template type diffing. Template arguments for type aliases and template arguments for the underlying desugared type may not have one-to-one relations, which could mess us the attempt to get more information from the desugared type. For type aliases, ignore the iterator over the desugared type. llvm-svn: 264940
2016-03-30 22:23:00 +00:00
"Desugared TemplateArgument should not be used.");
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
return *DesugaredIterator;
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
};
// These functions build up the template diff tree, including functions to
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
// retrieve and compare template arguments.
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
static const TemplateSpecializationType *
GetTemplateSpecializationType(ASTContext &Context, QualType Ty) {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
if (const TemplateSpecializationType *TST =
Ty->getAs<TemplateSpecializationType>())
return TST;
Fix missing qualifier in template type diffing Handle SubstTemplateTypeParmType so qualifiers do not get dropped from the diagnostic message.
2021-08-16 16:54:10 -07:00
if (const auto* SubstType = Ty->getAs<SubstTemplateTypeParmType>())
Ty = SubstType->getReplacementType();
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
const RecordType *RT = Ty->getAs<RecordType>();
if (!RT)
[C++11] Use 'nullptr'. AST edition. llvm-svn: 208517
2014-05-12 05:36:57 +00:00
return nullptr;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
const ClassTemplateSpecializationDecl *CTSD =
dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
if (!CTSD)
[C++11] Use 'nullptr'. AST edition. llvm-svn: 208517
2014-05-12 05:36:57 +00:00
return nullptr;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Ty = Context.getTemplateSpecializationType(
Reland: [clang] Improved canonicalization for template specialization types (#135414) This relands https://github.com/llvm/llvm-project/pull/135119, after fixing crashes seen in LLDB CI reported here: https://github.com/llvm/llvm-project/pull/135119#issuecomment-2794910840 Fixes https://github.com/llvm/llvm-project/pull/135119 This changes the TemplateArgument representation to hold a flag indicating whether a tempalte argument of expression type is supposed to be canonical or not. This gets one step closer to solving https://github.com/llvm/llvm-project/issues/92292 This still doesn't try to unique as-written TSTs. While this would increase the amount of memory savings and make code dealing with the AST more well-behaved, profiling template argument lists is still too expensive for this to be worthwhile, at least for now. This also fixes the context creation of TSTs, so that they don't in some cases get incorrectly flagged as sugar over their own canonical form. This is captured in the test expectation change of some AST dumps. This fixes some places which were unnecessarily canonicalizing these TSTs.
2025-04-12 14:26:30 -03:00
TemplateName(CTSD->getSpecializedTemplate()),
CTSD->getTemplateArgs().asArray(), /*CanonicalArgs=*/std::nullopt,
Ty.getLocalUnqualifiedType().getCanonicalType());
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
return Ty->getAs<TemplateSpecializationType>();
}
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// Returns true if the DiffType is Type and false for Template.
static bool OnlyPerformTypeDiff(ASTContext &Context, QualType FromType,
QualType ToType,
const TemplateSpecializationType *&FromArgTST,
const TemplateSpecializationType *&ToArgTST) {
if (FromType.isNull() || ToType.isNull())
return true;
if (Context.hasSameType(FromType, ToType))
return true;
FromArgTST = GetTemplateSpecializationType(Context, FromType);
ToArgTST = GetTemplateSpecializationType(Context, ToType);
if (!FromArgTST || !ToArgTST)
return true;
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
if (!hasSameTemplate(Context, FromArgTST, ToArgTST))
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
return true;
return false;
}
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
/// DiffTypes - Fills a DiffNode with information about a type difference.
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
void DiffTypes(const TSTiterator &FromIter, const TSTiterator &ToIter) {
QualType FromType = GetType(FromIter);
QualType ToType = GetType(ToIter);
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
bool FromDefault = FromIter.isEnd() && !FromType.isNull();
bool ToDefault = ToIter.isEnd() && !ToType.isNull();
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
const TemplateSpecializationType *FromArgTST = nullptr;
const TemplateSpecializationType *ToArgTST = nullptr;
if (OnlyPerformTypeDiff(Context, FromType, ToType, FromArgTST, ToArgTST)) {
Tree.SetTypeDiff(FromType, ToType, FromDefault, ToDefault);
Tree.SetSame(!FromType.isNull() && !ToType.isNull() &&
Context.hasSameType(FromType, ToType));
} else {
assert(FromArgTST && ToArgTST &&
"Both template specializations need to be valid.");
Qualifiers FromQual = FromType.getQualifiers(),
ToQual = ToType.getQualifiers();
FromQual -= QualType(FromArgTST, 0).getQualifiers();
ToQual -= QualType(ToArgTST, 0).getQualifiers();
Tree.SetTemplateDiff(FromArgTST->getTemplateName().getAsTemplateDecl(),
ToArgTST->getTemplateName().getAsTemplateDecl(),
FromQual, ToQual, FromDefault, ToDefault);
DiffTemplate(FromArgTST, ToArgTST);
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
}
}
/// DiffTemplateTemplates - Fills a DiffNode with information about a
/// template template difference.
void DiffTemplateTemplates(const TSTiterator &FromIter,
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
const TSTiterator &ToIter) {
TemplateDecl *FromDecl = GetTemplateDecl(FromIter);
TemplateDecl *ToDecl = GetTemplateDecl(ToIter);
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
Tree.SetTemplateTemplateDiff(FromDecl, ToDecl, FromIter.isEnd() && FromDecl,
ToIter.isEnd() && ToDecl);
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
Tree.SetSame(FromDecl && ToDecl &&
FromDecl->getCanonicalDecl() == ToDecl->getCanonicalDecl());
}
/// InitializeNonTypeDiffVariables - Helper function for DiffNonTypes
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
static void InitializeNonTypeDiffVariables(ASTContext &Context,
const TSTiterator &Iter,
NonTypeTemplateParmDecl *Default,
llvm::APSInt &Value, bool &HasInt,
QualType &IntType, bool &IsNullPtr,
Expr *&E, ValueDecl *&VD,
bool &NeedAddressOf) {
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
if (!Iter.isEnd()) {
switch (Iter->getKind()) {
[clang] Avoid crash due to unimplemented StructuralValue support in the template differ (#93265) This was not implemented in https://github.com/llvm/llvm-project/pull/78041 when StructuralValue TemplateArguments were originally added. This patch does not implement this functionality, it just falls back to the expression when possible. Otherwise, such as when dealing with canonical types to begin with, this will just ignore the argument as if it wasn't even there. Fixes https://github.com/llvm/llvm-project/issues/93068
2024-05-24 11:33:16 -03:00
case TemplateArgument::StructuralValue:
// FIXME: Diffing of structural values is not implemented.
// There is no possible fallback in this case, this will show up
// as '(no argument)'.
return;
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
case TemplateArgument::Integral:
[clang] Avoid crash due to unimplemented StructuralValue support in the template differ (#93265) This was not implemented in https://github.com/llvm/llvm-project/pull/78041 when StructuralValue TemplateArguments were originally added. This patch does not implement this functionality, it just falls back to the expression when possible. Otherwise, such as when dealing with canonical types to begin with, this will just ignore the argument as if it wasn't even there. Fixes https://github.com/llvm/llvm-project/issues/93068
2024-05-24 11:33:16 -03:00
Value = Iter->getAsIntegral();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
HasInt = true;
[clang] Avoid crash due to unimplemented StructuralValue support in the template differ (#93265) This was not implemented in https://github.com/llvm/llvm-project/pull/78041 when StructuralValue TemplateArguments were originally added. This patch does not implement this functionality, it just falls back to the expression when possible. Otherwise, such as when dealing with canonical types to begin with, this will just ignore the argument as if it wasn't even there. Fixes https://github.com/llvm/llvm-project/issues/93068
2024-05-24 11:33:16 -03:00
IntType = Iter->getIntegralType();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
return;
case TemplateArgument::Declaration: {
[clang] Avoid crash due to unimplemented StructuralValue support in the template differ (#93265) This was not implemented in https://github.com/llvm/llvm-project/pull/78041 when StructuralValue TemplateArguments were originally added. This patch does not implement this functionality, it just falls back to the expression when possible. Otherwise, such as when dealing with canonical types to begin with, this will just ignore the argument as if it wasn't even there. Fixes https://github.com/llvm/llvm-project/issues/93068
2024-05-24 11:33:16 -03:00
VD = Iter->getAsDecl();
QualType ArgType = Iter->getParamTypeForDecl();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
QualType VDType = VD->getType();
if (ArgType->isPointerType() &&
Context.hasSameType(ArgType->getPointeeType(), VDType))
NeedAddressOf = true;
return;
}
case TemplateArgument::NullPtr:
IsNullPtr = true;
return;
case TemplateArgument::Expression:
[clang] Avoid crash due to unimplemented StructuralValue support in the template differ (#93265) This was not implemented in https://github.com/llvm/llvm-project/pull/78041 when StructuralValue TemplateArguments were originally added. This patch does not implement this functionality, it just falls back to the expression when possible. Otherwise, such as when dealing with canonical types to begin with, this will just ignore the argument as if it wasn't even there. Fixes https://github.com/llvm/llvm-project/issues/93068
2024-05-24 11:33:16 -03:00
E = Iter->getAsExpr();
break;
case TemplateArgument::Null:
case TemplateArgument::Type:
case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion:
llvm_unreachable("TemplateArgument kind is not expected for NTTP");
case TemplateArgument::Pack:
llvm_unreachable("TemplateArgument kind should be handled elsewhere");
}
} else if (!Default->isParameterPack()) {
E = Default->getDefaultArgument().getArgument().getAsExpr();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
}
[clang] Avoid crash due to unimplemented StructuralValue support in the template differ (#93265) This was not implemented in https://github.com/llvm/llvm-project/pull/78041 when StructuralValue TemplateArguments were originally added. This patch does not implement this functionality, it just falls back to the expression when possible. Otherwise, such as when dealing with canonical types to begin with, this will just ignore the argument as if it wasn't even there. Fixes https://github.com/llvm/llvm-project/issues/93068
2024-05-24 11:33:16 -03:00
if (!Iter.hasDesugaredTA())
return;
const TemplateArgument &TA = Iter.getDesugaredTA();
switch (TA.getKind()) {
case TemplateArgument::StructuralValue:
// FIXME: Diffing of structural values is not implemented.
// Just fall back to the expression.
return;
case TemplateArgument::Integral:
Value = TA.getAsIntegral();
HasInt = true;
IntType = TA.getIntegralType();
return;
case TemplateArgument::Declaration: {
VD = TA.getAsDecl();
QualType ArgType = TA.getParamTypeForDecl();
QualType VDType = VD->getType();
if (ArgType->isPointerType() &&
Context.hasSameType(ArgType->getPointeeType(), VDType))
NeedAddressOf = true;
return;
}
case TemplateArgument::NullPtr:
IsNullPtr = true;
return;
case TemplateArgument::Expression:
// TODO: Sometimes, the desugared template argument Expr differs from
// the sugared template argument Expr. It may be useful in the future
// but for now, it is just discarded.
if (!E)
E = TA.getAsExpr();
return;
case TemplateArgument::Null:
case TemplateArgument::Type:
case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion:
llvm_unreachable("TemplateArgument kind is not expected for NTTP");
case TemplateArgument::Pack:
llvm_unreachable("TemplateArgument kind should be handled elsewhere");
}
llvm_unreachable("Unexpected TemplateArgument kind");
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
}
/// DiffNonTypes - Handles any template parameters not handled by DiffTypes
/// of DiffTemplatesTemplates, such as integer and declaration parameters.
void DiffNonTypes(const TSTiterator &FromIter, const TSTiterator &ToIter,
NonTypeTemplateParmDecl *FromDefaultNonTypeDecl,
NonTypeTemplateParmDecl *ToDefaultNonTypeDecl) {
Expr *FromExpr = nullptr, *ToExpr = nullptr;
llvm::APSInt FromInt, ToInt;
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
QualType FromIntType, ToIntType;
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
ValueDecl *FromValueDecl = nullptr, *ToValueDecl = nullptr;
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
bool HasFromInt = false, HasToInt = false, FromNullPtr = false,
ToNullPtr = false, NeedFromAddressOf = false, NeedToAddressOf = false;
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
InitializeNonTypeDiffVariables(
Context, FromIter, FromDefaultNonTypeDecl, FromInt, HasFromInt,
FromIntType, FromNullPtr, FromExpr, FromValueDecl, NeedFromAddressOf);
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
InitializeNonTypeDiffVariables(Context, ToIter, ToDefaultNonTypeDecl, ToInt,
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
HasToInt, ToIntType, ToNullPtr, ToExpr,
ToValueDecl, NeedToAddressOf);
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
bool FromDefault = FromIter.isEnd() &&
(FromExpr || FromValueDecl || HasFromInt || FromNullPtr);
bool ToDefault = ToIter.isEnd() &&
(ToExpr || ToValueDecl || HasToInt || ToNullPtr);
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 05:01:53 +00:00
bool FromDeclaration = FromValueDecl || FromNullPtr;
bool ToDeclaration = ToValueDecl || ToNullPtr;
if (FromDeclaration && HasToInt) {
Tree.SetFromDeclarationAndToIntegerDiff(
FromValueDecl, NeedFromAddressOf, FromNullPtr, FromExpr, ToInt,
HasToInt, ToIntType, ToExpr, FromDefault, ToDefault);
Tree.SetSame(false);
return;
}
if (HasFromInt && ToDeclaration) {
Tree.SetFromIntegerAndToDeclarationDiff(
FromInt, HasFromInt, FromIntType, FromExpr, ToValueDecl,
NeedToAddressOf, ToNullPtr, ToExpr, FromDefault, ToDefault);
Tree.SetSame(false);
return;
}
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
if (HasFromInt || HasToInt) {
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
Tree.SetIntegerDiff(FromInt, ToInt, HasFromInt, HasToInt, FromIntType,
ToIntType, FromExpr, ToExpr, FromDefault, ToDefault);
When checking the template argument list, use a copy of that list for changes and only update the orginal list on a valid arugment list. When checking an individual expression template argument, and conversions are required, update the expression in the template argument. Since template arguments are speculatively checked, the copying of the template argument list prevents updating the template arguments when the list does not match the template. Additionally, clean up the integer checking code in the template diffing code. The code performs unneccessary conversions from APSInt to APInt. Fixes PR21758. This essentially reverts r224770 to recommits r224667 and r224668 with extra changes to prevent the template instantiation problems seen in PR22006. A test to catch the discovered problem is also added. llvm-svn: 226983
2015-01-24 02:48:32 +00:00
if (HasFromInt && HasToInt) {
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
Tree.SetSame(Context.hasSameType(FromIntType, ToIntType) &&
FromInt == ToInt);
When checking the template argument list, use a copy of that list for changes and only update the orginal list on a valid arugment list. When checking an individual expression template argument, and conversions are required, update the expression in the template argument. Since template arguments are speculatively checked, the copying of the template argument list prevents updating the template arguments when the list does not match the template. Additionally, clean up the integer checking code in the template diffing code. The code performs unneccessary conversions from APSInt to APInt. Fixes PR21758. This essentially reverts r224770 to recommits r224667 and r224668 with extra changes to prevent the template instantiation problems seen in PR22006. A test to catch the discovered problem is also added. llvm-svn: 226983
2015-01-24 02:48:32 +00:00
}
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
return;
}
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
if (FromDeclaration || ToDeclaration) {
Tree.SetDeclarationDiff(FromValueDecl, ToValueDecl, NeedFromAddressOf,
NeedToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
ToExpr, FromDefault, ToDefault);
bool BothNull = FromNullPtr && ToNullPtr;
bool SameValueDecl =
FromValueDecl && ToValueDecl &&
NeedFromAddressOf == NeedToAddressOf &&
FromValueDecl->getCanonicalDecl() == ToValueDecl->getCanonicalDecl();
Tree.SetSame(BothNull || SameValueDecl);
return;
}
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
assert((FromExpr || ToExpr) && "Both template arguments cannot be empty.");
Tree.SetExpressionDiff(FromExpr, ToExpr, FromDefault, ToDefault);
Tree.SetSame(IsEqualExpr(Context, FromExpr, ToExpr));
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// DiffTemplate - recursively visits template arguments and stores the
/// argument info into a tree.
void DiffTemplate(const TemplateSpecializationType *FromTST,
const TemplateSpecializationType *ToTST) {
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
// FIXME: With P3310R0, A TST formed from a DeducedTemplateName might
// differ in template arguments which were not written.
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
// Begin descent into diffing template tree.
Fix an edge case in the template differ with default arguments. In the test case one type is coming from a typedef with no default arg, the other has the default arg. Taking the default arg from the typedef crashes, so always use the real template paramter declaration. PR17510. llvm-svn: 192202
2013-10-08 16:58:52 +00:00
TemplateParameterList *ParamsFrom =
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
FromTST->getTemplateName()
.getAsTemplateDecl(/*IgnoreDeduced=*/true)
->getTemplateParameters();
Fix an edge case in the template differ with default arguments. In the test case one type is coming from a typedef with no default arg, the other has the default arg. Taking the default arg from the typedef crashes, so always use the real template paramter declaration. PR17510. llvm-svn: 192202
2013-10-08 16:58:52 +00:00
TemplateParameterList *ParamsTo =
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
ToTST->getTemplateName()
.getAsTemplateDecl(/*IgnoreDeduced=*/true)
->getTemplateParameters();
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
unsigned TotalArgs = 0;
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
for (TSTiterator FromIter(Context, FromTST), ToIter(Context, ToTST);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
!FromIter.isEnd() || !ToIter.isEnd(); ++TotalArgs) {
Tree.AddNode();
// Get the parameter at index TotalArgs. If index is larger
// than the total number of parameters, then there is an
// argument pack, so re-use the last parameter.
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
unsigned FromParamIndex = std::min(TotalArgs, ParamsFrom->size() - 1);
unsigned ToParamIndex = std::min(TotalArgs, ParamsTo->size() - 1);
NamedDecl *FromParamND = ParamsFrom->getParam(FromParamIndex);
NamedDecl *ToParamND = ParamsTo->getParam(ToParamIndex);
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
assert(FromParamND->getKind() == ToParamND->getKind() &&
"Parameter Decl are not the same kind.");
if (isa<TemplateTypeParmDecl>(FromParamND)) {
DiffTypes(FromIter, ToIter);
} else if (isa<TemplateTemplateParmDecl>(FromParamND)) {
DiffTemplateTemplates(FromIter, ToIter);
} else if (isa<NonTypeTemplateParmDecl>(FromParamND)) {
NonTypeTemplateParmDecl *FromDefaultNonTypeDecl =
cast<NonTypeTemplateParmDecl>(FromParamND);
NonTypeTemplateParmDecl *ToDefaultNonTypeDecl =
cast<NonTypeTemplateParmDecl>(ToParamND);
Refactor one of the larger functions for Type Diffing into smaller functions. No functionality change. llvm-svn: 216526
2014-08-27 06:24:47 +00:00
DiffNonTypes(FromIter, ToIter, FromDefaultNonTypeDecl,
ToDefaultNonTypeDecl);
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
} else {
llvm_unreachable("Unexpected Decl type.");
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
++FromIter;
++ToIter;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Tree.Up();
}
}
Clean up part of template type diffing. Moved repeated code to separate functions. Reworked one of the conditionals. No functional changes. llvm-svn: 164839
2012-09-28 19:51:57 +00:00
/// makeTemplateList - Dump every template alias into the vector.
static void makeTemplateList(
Use SmallVectorImpl& for function arguments instead of SmallVector. llvm-svn: 185715
2013-07-05 19:34:19 +00:00
SmallVectorImpl<const TemplateSpecializationType *> &TemplateList,
Clean up part of template type diffing. Moved repeated code to separate functions. Reworked one of the conditionals. No functional changes. llvm-svn: 164839
2012-09-28 19:51:57 +00:00
const TemplateSpecializationType *TST) {
while (TST) {
TemplateList.push_back(TST);
if (!TST->isTypeAlias())
return;
TST = TST->getAliasedType()->getAs<TemplateSpecializationType>();
}
}
/// hasSameBaseTemplate - Returns true when the base templates are the same,
/// even if the template arguments are not.
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
static bool hasSameBaseTemplate(ASTContext &Context,
const TemplateSpecializationType *FromTST,
Clean up part of template type diffing. Moved repeated code to separate functions. Reworked one of the conditionals. No functional changes. llvm-svn: 164839
2012-09-28 19:51:57 +00:00
const TemplateSpecializationType *ToTST) {
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
return Context.getCanonicalTemplateName(FromTST->getTemplateName(),
/*IgnoreDeduced=*/true) ==
Context.getCanonicalTemplateName(ToTST->getTemplateName(),
/*IgnoreDeduced=*/true);
Clean up part of template type diffing. Moved repeated code to separate functions. Reworked one of the conditionals. No functional changes. llvm-svn: 164839
2012-09-28 19:51:57 +00:00
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// hasSameTemplate - Returns true if both types are specialized from the
/// same template declaration. If they come from different template aliases,
/// do a parallel ascension search to determine the highest template alias in
/// common and set the arguments to them.
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
static bool hasSameTemplate(ASTContext &Context,
const TemplateSpecializationType *&FromTST,
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
const TemplateSpecializationType *&ToTST) {
// Check the top templates if they are the same.
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
if (hasSameBaseTemplate(Context, FromTST, ToTST))
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
return true;
// Create vectors of template aliases.
SmallVector<const TemplateSpecializationType*, 1> FromTemplateList,
ToTemplateList;
Clean up part of template type diffing. Moved repeated code to separate functions. Reworked one of the conditionals. No functional changes. llvm-svn: 164839
2012-09-28 19:51:57 +00:00
makeTemplateList(FromTemplateList, FromTST);
makeTemplateList(ToTemplateList, ToTST);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Use SmallVectorImpl::reverse_iterator instead of SmallVector to avoid specifying the vector size. llvm-svn: 185784
2013-07-08 03:55:09 +00:00
SmallVectorImpl<const TemplateSpecializationType *>::reverse_iterator
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
FromIter = FromTemplateList.rbegin(), FromEnd = FromTemplateList.rend(),
ToIter = ToTemplateList.rbegin(), ToEnd = ToTemplateList.rend();
// Check if the lowest template types are the same. If not, return.
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
if (!hasSameBaseTemplate(Context, *FromIter, *ToIter))
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
return false;
// Begin searching up the template aliases. The bottom most template
// matches so move up until one pair does not match. Use the template
// right before that one.
for (; FromIter != FromEnd && ToIter != ToEnd; ++FromIter, ++ToIter) {
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
if (!hasSameBaseTemplate(Context, *FromIter, *ToIter))
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
break;
}
FromTST = FromIter[-1];
ToTST = ToIter[-1];
return true;
}
/// GetType - Retrieves the template type arguments, including default
/// arguments.
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
static QualType GetType(const TSTiterator &Iter) {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
if (!Iter.isEnd())
Refactor the Get* functions to be more consistant among themselves. llvm-svn: 178613
2013-04-03 03:06:48 +00:00
return Iter->getAsType();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
if (Iter.hasDesugaredTA())
Change the TSTiterator in Template Type Diffing. Modify the TSTiterator to have two internal iterators, which will walk the provided sugared type and the desugared type. This will provide better access to the template argument information. No functional changes. llvm-svn: 257838
2016-01-14 23:30:12 +00:00
return Iter.getDesugaredTA().getAsType();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
return QualType();
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 04:24:50 +00:00
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// GetTemplateDecl - Retrieves the template template arguments, including
/// default arguments.
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
static TemplateDecl *GetTemplateDecl(const TSTiterator &Iter) {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
if (!Iter.isEnd())
Refactor the Get* functions to be more consistant among themselves. llvm-svn: 178613
2013-04-03 03:06:48 +00:00
return Iter->getAsTemplate().getAsTemplateDecl();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
if (Iter.hasDesugaredTA())
return Iter.getDesugaredTA().getAsTemplate().getAsTemplateDecl();
[C++11] Use 'nullptr'. AST edition. llvm-svn: 208517
2014-05-12 05:36:57 +00:00
return nullptr;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
/// IsEqualExpr - Returns true if the expressions are the same in regards to
/// template arguments. These expressions are dependent, so profile them
/// instead of trying to evaluate them.
When checking the template argument list, use a copy of that list for changes and only update the orginal list on a valid arugment list. When checking an individual expression template argument, and conversions are required, update the expression in the template argument. Since template arguments are speculatively checked, the copying of the template argument list prevents updating the template arguments when the list does not match the template. Additionally, clean up the integer checking code in the template diffing code. The code performs unneccessary conversions from APSInt to APInt. Fixes PR21758. This essentially reverts r224770 to recommits r224667 and r224668 with extra changes to prevent the template instantiation problems seen in PR22006. A test to catch the discovered problem is also added. llvm-svn: 226983
2015-01-24 02:48:32 +00:00
static bool IsEqualExpr(ASTContext &Context, Expr *FromExpr, Expr *ToExpr) {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
if (FromExpr == ToExpr)
return true;
if (!FromExpr || !ToExpr)
return false;
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
llvm::FoldingSetNodeID FromID, ToID;
FromExpr->Profile(FromID, Context, true);
ToExpr->Profile(ToID, Context, true);
return FromID == ToID;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
// These functions converts the tree representation of the template
// differences into the internal character vector.
/// TreeToString - Converts the Tree object into a character stream which
/// will later be turned into the output string.
void TreeToString(int Indent = 1) {
if (PrintTree) {
OS << '\n';
Use raw_ostream::indent, update comment. llvm-svn: 175897
2013-02-22 16:13:34 +00:00
OS.indent(2 * Indent);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
++Indent;
}
// Handle cases where the difference is not templates with different
// arguments.
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
switch (Tree.GetKind()) {
case DiffTree::Invalid:
llvm_unreachable("Template diffing failed with bad DiffNode");
case DiffTree::Type: {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
QualType FromType, ToType;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
Tree.GetTypeDiff(FromType, ToType);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
PrintTypeNames(FromType, ToType, Tree.FromDefault(), Tree.ToDefault(),
Tree.NodeIsSame());
return;
}
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
case DiffTree::Expression: {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Expr *FromExpr, *ToExpr;
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
Tree.GetExpressionDiff(FromExpr, ToExpr);
PrintExpr(FromExpr, ToExpr, Tree.FromDefault(), Tree.ToDefault(),
Tree.NodeIsSame());
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
return;
}
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
case DiffTree::TemplateTemplate: {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
TemplateDecl *FromTD, *ToTD;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
Tree.GetTemplateTemplateDiff(FromTD, ToTD);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
PrintTemplateTemplate(FromTD, ToTD, Tree.FromDefault(),
Tree.ToDefault(), Tree.NodeIsSame());
return;
}
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
case DiffTree::Integer: {
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-01 21:29:28 +00:00
llvm::APSInt FromInt, ToInt;
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
Expr *FromExpr, *ToExpr;
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-01 21:29:28 +00:00
bool IsValidFromInt, IsValidToInt;
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
QualType FromIntType, ToIntType;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
Tree.GetIntegerDiff(FromInt, ToInt, IsValidFromInt, IsValidToInt,
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
FromIntType, ToIntType, FromExpr, ToExpr);
PrintAPSInt(FromInt, ToInt, IsValidFromInt, IsValidToInt, FromIntType,
ToIntType, FromExpr, ToExpr, Tree.FromDefault(),
Tree.ToDefault(), Tree.NodeIsSame());
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-01 21:29:28 +00:00
return;
}
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
case DiffTree::Declaration: {
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
ValueDecl *FromValueDecl, *ToValueDecl;
Fix crash on invalid in template type diffing. This is a fix for PR15895, where Clang will crash when trying to print a template diff and the template uses an address of operator. This resulted from expecting a DeclRefExpr when the Expr could have also been UnaryOperator->DeclRefExpr. llvm-svn: 181365
2013-05-07 21:36:24 +00:00
bool FromAddressOf, ToAddressOf;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
bool FromNullPtr, ToNullPtr;
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
Expr *FromExpr, *ToExpr;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
Tree.GetDeclarationDiff(FromValueDecl, ToValueDecl, FromAddressOf,
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
ToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
ToExpr);
Fix crash on invalid in template type diffing. This is a fix for PR15895, where Clang will crash when trying to print a template diff and the template uses an address of operator. This resulted from expecting a DeclRefExpr when the Expr could have also been UnaryOperator->DeclRefExpr. llvm-svn: 181365
2013-05-07 21:36:24 +00:00
PrintValueDecl(FromValueDecl, ToValueDecl, FromAddressOf, ToAddressOf,
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
FromNullPtr, ToNullPtr, FromExpr, ToExpr,
Tree.FromDefault(), Tree.ToDefault(), Tree.NodeIsSame());
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
return;
}
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 05:01:53 +00:00
case DiffTree::FromDeclarationAndToInteger: {
ValueDecl *FromValueDecl;
bool FromAddressOf;
bool FromNullPtr;
Expr *FromExpr;
llvm::APSInt ToInt;
bool IsValidToInt;
QualType ToIntType;
Expr *ToExpr;
Tree.GetFromDeclarationAndToIntegerDiff(
FromValueDecl, FromAddressOf, FromNullPtr, FromExpr, ToInt,
IsValidToInt, ToIntType, ToExpr);
assert((FromValueDecl || FromNullPtr) && IsValidToInt);
PrintValueDeclAndInteger(FromValueDecl, FromAddressOf, FromNullPtr,
FromExpr, Tree.FromDefault(), ToInt, ToIntType,
ToExpr, Tree.ToDefault());
return;
}
case DiffTree::FromIntegerAndToDeclaration: {
llvm::APSInt FromInt;
bool IsValidFromInt;
QualType FromIntType;
Expr *FromExpr;
ValueDecl *ToValueDecl;
bool ToAddressOf;
bool ToNullPtr;
Expr *ToExpr;
Tree.GetFromIntegerAndToDeclarationDiff(
FromInt, IsValidFromInt, FromIntType, FromExpr, ToValueDecl,
ToAddressOf, ToNullPtr, ToExpr);
assert(IsValidFromInt && (ToValueDecl || ToNullPtr));
PrintIntegerAndValueDecl(FromInt, FromIntType, FromExpr,
Tree.FromDefault(), ToValueDecl, ToAddressOf,
ToNullPtr, ToExpr, Tree.ToDefault());
return;
}
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
case DiffTree::Template: {
// Node is root of template. Recurse on children.
TemplateDecl *FromTD, *ToTD;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
Qualifiers FromQual, ToQual;
Tree.GetTemplateDiff(FromTD, ToTD, FromQual, ToQual);
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 05:48:38 +00:00
PrintQualifiers(FromQual, ToQual);
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
if (!Tree.HasChildren()) {
// If we're dealing with a template specialization with zero
// arguments, there are no children; special-case this.
[clang][nearly-NFC] Remove some superfluous uses of NamedDecl::getNameAsString `OS << ND->getDeclName();` is equivalent to `OS << ND->getNameAsString();` without the extra temporary string. This is not quite a NFC since two uses of `getNameAsString` in a diagnostic are replaced, which results in the named entity being quoted with additional "'"s (ie: 'var' instead of var).
2020-08-05 11:48:09 +01:00
OS << FromTD->getDeclName() << "<>";
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
return;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
[clang][nearly-NFC] Remove some superfluous uses of NamedDecl::getNameAsString `OS << ND->getDeclName();` is equivalent to `OS << ND->getNameAsString();` without the extra temporary string. This is not quite a NFC since two uses of `getNameAsString` in a diagnostic are replaced, which results in the named entity being quoted with additional "'"s (ie: 'var' instead of var).
2020-08-05 11:48:09 +01:00
OS << FromTD->getDeclName() << '<';
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
Tree.MoveToChild();
unsigned NumElideArgs = 0;
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 00:36:59 +00:00
bool AllArgsElided = true;
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
do {
if (ElideType) {
if (Tree.NodeIsSame()) {
++NumElideArgs;
continue;
}
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 00:36:59 +00:00
AllArgsElided = false;
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
if (NumElideArgs > 0) {
PrintElideArgs(NumElideArgs, Indent);
NumElideArgs = 0;
OS << ", ";
}
}
TreeToString(Indent);
if (Tree.HasNextSibling())
OS << ", ";
} while (Tree.AdvanceSibling());
Template Type Diffing change When all the arguments of a template are elided, print "A<...>" instead of "A<[2 * ...]>". Also remove comment fragment that means nothing. llvm-svn: 259445
2016-02-02 00:36:59 +00:00
if (NumElideArgs > 0) {
if (AllArgsElided)
OS << "...";
else
PrintElideArgs(NumElideArgs, Indent);
}
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
Tree.Parent();
OS << ">";
return;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
Refactor template diffing to store an enum that records which type of difference is stored inside a DiffNode. This should not change any diagnostic messages. llvm-svn: 177180
2013-03-15 20:35:18 +00:00
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
// To signal to the text printer that a certain text needs to be bolded,
// a special character is injected into the character stream which the
// text printer will later strip out.
/// Bold - Start bolding text.
void Bold() {
assert(!IsBold && "Attempting to bold text that is already bold.");
IsBold = true;
if (ShowColor)
OS << ToggleHighlight;
}
/// Unbold - Stop bolding text.
void Unbold() {
assert(IsBold && "Attempting to remove bold from unbold text.");
IsBold = false;
if (ShowColor)
OS << ToggleHighlight;
}
// Functions to print out the arguments and highlighting the difference.
/// PrintTypeNames - prints the typenames, bolding differences. Will detect
/// typenames that are the same and attempt to disambiguate them by using
/// canonical typenames.
void PrintTypeNames(QualType FromType, QualType ToType,
bool FromDefault, bool ToDefault, bool Same) {
assert((!FromType.isNull() || !ToType.isNull()) &&
"Only one template argument may be missing.");
if (Same) {
Pass the PrintingPolicy when converting types to strings in template type diffing. This removes extra "struct"/"class" in the type names and gives "bool" instead of "_Bool" for booleans. llvm-svn: 213912
2014-07-25 00:24:02 +00:00
OS << FromType.getAsString(Policy);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
return;
}
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-28 20:32:51 +00:00
if (!FromType.isNull() && !ToType.isNull() &&
FromType.getLocalUnqualifiedType() ==
ToType.getLocalUnqualifiedType()) {
Qualifiers FromQual = FromType.getLocalQualifiers(),
Remove some unused locals llvm-svn: 195714
2013-11-26 02:52:41 +00:00
ToQual = ToType.getLocalQualifiers();
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-28 20:32:51 +00:00
PrintQualifiers(FromQual, ToQual);
FromType.getLocalUnqualifiedType().print(OS, Policy);
return;
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
std::string FromTypeStr = FromType.isNull() ? "(no argument)"
Pass the PrintingPolicy when converting types to strings in template type diffing. This removes extra "struct"/"class" in the type names and gives "bool" instead of "_Bool" for booleans. llvm-svn: 213912
2014-07-25 00:24:02 +00:00
: FromType.getAsString(Policy);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
std::string ToTypeStr = ToType.isNull() ? "(no argument)"
Pass the PrintingPolicy when converting types to strings in template type diffing. This removes extra "struct"/"class" in the type names and gives "bool" instead of "_Bool" for booleans. llvm-svn: 213912
2014-07-25 00:24:02 +00:00
: ToType.getAsString(Policy);
[clang] Implement ElaboratedType sugaring for types written bare Without this patch, clang will not wrap in an ElaboratedType node types written without a keyword and nested name qualifier, which goes against the intent that we should produce an AST which retains enough details to recover how things are written. The lack of this sugar is incompatible with the intent of the type printer default policy, which is to print types as written, but to fall back and print them fully qualified when they are desugared. An ElaboratedTypeLoc without keyword / NNS uses no storage by itself, but still requires pointer alignment due to pre-existing bug in the TypeLoc buffer handling. --- Troubleshooting list to deal with any breakage seen with this patch: 1) The most likely effect one would see by this patch is a change in how a type is printed. The type printer will, by design and default, print types as written. There are customization options there, but not that many, and they mainly apply to how to print a type that we somehow failed to track how it was written. This patch fixes a problem where we failed to distinguish between a type that was written without any elaborated-type qualifiers, such as a 'struct'/'class' tags and name spacifiers such as 'std::', and one that has been stripped of any 'metadata' that identifies such, the so called canonical types. Example: ``` namespace foo { struct A {}; A a; }; ``` If one were to print the type of `foo::a`, prior to this patch, this would result in `foo::A`. This is how the type printer would have, by default, printed the canonical type of A as well. As soon as you add any name qualifiers to A, the type printer would suddenly start accurately printing the type as written. This patch will make it print it accurately even when written without qualifiers, so we will just print `A` for the initial example, as the user did not really write that `foo::` namespace qualifier. 2) This patch could expose a bug in some AST matcher. Matching types is harder to get right when there is sugar involved. For example, if you want to match a type against being a pointer to some type A, then you have to account for getting a type that is sugar for a pointer to A, or being a pointer to sugar to A, or both! Usually you would get the second part wrong, and this would work for a very simple test where you don't use any name qualifiers, but you would discover is broken when you do. The usual fix is to either use the matcher which strips sugar, which is annoying to use as for example if you match an N level pointer, you have to put N+1 such matchers in there, beginning to end and between all those levels. But in a lot of cases, if the property you want to match is present in the canonical type, it's easier and faster to just match on that... This goes with what is said in 1), if you want to match against the name of a type, and you want the name string to be something stable, perhaps matching on the name of the canonical type is the better choice. 3) This patch could expose a bug in how you get the source range of some TypeLoc. For some reason, a lot of code is using getLocalSourceRange(), which only looks at the given TypeLoc node. This patch introduces a new, and more common TypeLoc node which contains no source locations on itself. This is not an inovation here, and some other, more rare TypeLoc nodes could also have this property, but if you use getLocalSourceRange on them, it's not going to return any valid locations, because it doesn't have any. The right fix here is to always use getSourceRange() or getBeginLoc/getEndLoc which will dive into the inner TypeLoc to get the source range if it doesn't find it on the top level one. You can use getLocalSourceRange if you are really into micro-optimizations and you have some outside knowledge that the TypeLocs you are dealing with will always include some source location. 4) Exposed a bug somewhere in the use of the normal clang type class API, where you have some type, you want to see if that type is some particular kind, you try a `dyn_cast` such as `dyn_cast<TypedefType>` and that fails because now you have an ElaboratedType which has a TypeDefType inside of it, which is what you wanted to match. Again, like 2), this would usually have been tested poorly with some simple tests with no qualifications, and would have been broken had there been any other kind of type sugar, be it an ElaboratedType or a TemplateSpecializationType or a SubstTemplateParmType. The usual fix here is to use `getAs` instead of `dyn_cast`, which will look deeper into the type. Or use `getAsAdjusted` when dealing with TypeLocs. For some reason the API is inconsistent there and on TypeLocs getAs behaves like a dyn_cast. 5) It could be a bug in this patch perhaps. Let me know if you need any help! Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D112374
2021-10-11 18:15:36 +02:00
// Print without ElaboratedType sugar if it is better.
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
// TODO: merge this with other aka printing above.
if (FromTypeStr == ToTypeStr) {
[clang] Implement ElaboratedType sugaring for types written bare Without this patch, clang will not wrap in an ElaboratedType node types written without a keyword and nested name qualifier, which goes against the intent that we should produce an AST which retains enough details to recover how things are written. The lack of this sugar is incompatible with the intent of the type printer default policy, which is to print types as written, but to fall back and print them fully qualified when they are desugared. An ElaboratedTypeLoc without keyword / NNS uses no storage by itself, but still requires pointer alignment due to pre-existing bug in the TypeLoc buffer handling. --- Troubleshooting list to deal with any breakage seen with this patch: 1) The most likely effect one would see by this patch is a change in how a type is printed. The type printer will, by design and default, print types as written. There are customization options there, but not that many, and they mainly apply to how to print a type that we somehow failed to track how it was written. This patch fixes a problem where we failed to distinguish between a type that was written without any elaborated-type qualifiers, such as a 'struct'/'class' tags and name spacifiers such as 'std::', and one that has been stripped of any 'metadata' that identifies such, the so called canonical types. Example: ``` namespace foo { struct A {}; A a; }; ``` If one were to print the type of `foo::a`, prior to this patch, this would result in `foo::A`. This is how the type printer would have, by default, printed the canonical type of A as well. As soon as you add any name qualifiers to A, the type printer would suddenly start accurately printing the type as written. This patch will make it print it accurately even when written without qualifiers, so we will just print `A` for the initial example, as the user did not really write that `foo::` namespace qualifier. 2) This patch could expose a bug in some AST matcher. Matching types is harder to get right when there is sugar involved. For example, if you want to match a type against being a pointer to some type A, then you have to account for getting a type that is sugar for a pointer to A, or being a pointer to sugar to A, or both! Usually you would get the second part wrong, and this would work for a very simple test where you don't use any name qualifiers, but you would discover is broken when you do. The usual fix is to either use the matcher which strips sugar, which is annoying to use as for example if you match an N level pointer, you have to put N+1 such matchers in there, beginning to end and between all those levels. But in a lot of cases, if the property you want to match is present in the canonical type, it's easier and faster to just match on that... This goes with what is said in 1), if you want to match against the name of a type, and you want the name string to be something stable, perhaps matching on the name of the canonical type is the better choice. 3) This patch could expose a bug in how you get the source range of some TypeLoc. For some reason, a lot of code is using getLocalSourceRange(), which only looks at the given TypeLoc node. This patch introduces a new, and more common TypeLoc node which contains no source locations on itself. This is not an inovation here, and some other, more rare TypeLoc nodes could also have this property, but if you use getLocalSourceRange on them, it's not going to return any valid locations, because it doesn't have any. The right fix here is to always use getSourceRange() or getBeginLoc/getEndLoc which will dive into the inner TypeLoc to get the source range if it doesn't find it on the top level one. You can use getLocalSourceRange if you are really into micro-optimizations and you have some outside knowledge that the TypeLocs you are dealing with will always include some source location. 4) Exposed a bug somewhere in the use of the normal clang type class API, where you have some type, you want to see if that type is some particular kind, you try a `dyn_cast` such as `dyn_cast<TypedefType>` and that fails because now you have an ElaboratedType which has a TypeDefType inside of it, which is what you wanted to match. Again, like 2), this would usually have been tested poorly with some simple tests with no qualifications, and would have been broken had there been any other kind of type sugar, be it an ElaboratedType or a TemplateSpecializationType or a SubstTemplateParmType. The usual fix here is to use `getAs` instead of `dyn_cast`, which will look deeper into the type. Or use `getAsAdjusted` when dealing with TypeLocs. For some reason the API is inconsistent there and on TypeLocs getAs behaves like a dyn_cast. 5) It could be a bug in this patch perhaps. Let me know if you need any help! Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D112374
2021-10-11 18:15:36 +02:00
const auto *FromElTy = dyn_cast<ElaboratedType>(FromType),
*ToElTy = dyn_cast<ElaboratedType>(ToType);
if (FromElTy || ToElTy) {
std::string FromNamedTypeStr =
FromElTy ? FromElTy->getNamedType().getAsString(Policy)
: FromTypeStr;
std::string ToNamedTypeStr =
ToElTy ? ToElTy->getNamedType().getAsString(Policy) : ToTypeStr;
if (FromNamedTypeStr != ToNamedTypeStr) {
FromTypeStr = FromNamedTypeStr;
ToTypeStr = ToNamedTypeStr;
goto PrintTypes;
}
}
// Switch to canonical typename if it is better.
Pass the PrintingPolicy when converting types to strings in template type diffing. This removes extra "struct"/"class" in the type names and gives "bool" instead of "_Bool" for booleans. llvm-svn: 213912
2014-07-25 00:24:02 +00:00
std::string FromCanTypeStr =
FromType.getCanonicalType().getAsString(Policy);
std::string ToCanTypeStr = ToType.getCanonicalType().getAsString(Policy);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
if (FromCanTypeStr != ToCanTypeStr) {
FromTypeStr = FromCanTypeStr;
ToTypeStr = ToCanTypeStr;
}
}
[clang] Implement ElaboratedType sugaring for types written bare Without this patch, clang will not wrap in an ElaboratedType node types written without a keyword and nested name qualifier, which goes against the intent that we should produce an AST which retains enough details to recover how things are written. The lack of this sugar is incompatible with the intent of the type printer default policy, which is to print types as written, but to fall back and print them fully qualified when they are desugared. An ElaboratedTypeLoc without keyword / NNS uses no storage by itself, but still requires pointer alignment due to pre-existing bug in the TypeLoc buffer handling. --- Troubleshooting list to deal with any breakage seen with this patch: 1) The most likely effect one would see by this patch is a change in how a type is printed. The type printer will, by design and default, print types as written. There are customization options there, but not that many, and they mainly apply to how to print a type that we somehow failed to track how it was written. This patch fixes a problem where we failed to distinguish between a type that was written without any elaborated-type qualifiers, such as a 'struct'/'class' tags and name spacifiers such as 'std::', and one that has been stripped of any 'metadata' that identifies such, the so called canonical types. Example: ``` namespace foo { struct A {}; A a; }; ``` If one were to print the type of `foo::a`, prior to this patch, this would result in `foo::A`. This is how the type printer would have, by default, printed the canonical type of A as well. As soon as you add any name qualifiers to A, the type printer would suddenly start accurately printing the type as written. This patch will make it print it accurately even when written without qualifiers, so we will just print `A` for the initial example, as the user did not really write that `foo::` namespace qualifier. 2) This patch could expose a bug in some AST matcher. Matching types is harder to get right when there is sugar involved. For example, if you want to match a type against being a pointer to some type A, then you have to account for getting a type that is sugar for a pointer to A, or being a pointer to sugar to A, or both! Usually you would get the second part wrong, and this would work for a very simple test where you don't use any name qualifiers, but you would discover is broken when you do. The usual fix is to either use the matcher which strips sugar, which is annoying to use as for example if you match an N level pointer, you have to put N+1 such matchers in there, beginning to end and between all those levels. But in a lot of cases, if the property you want to match is present in the canonical type, it's easier and faster to just match on that... This goes with what is said in 1), if you want to match against the name of a type, and you want the name string to be something stable, perhaps matching on the name of the canonical type is the better choice. 3) This patch could expose a bug in how you get the source range of some TypeLoc. For some reason, a lot of code is using getLocalSourceRange(), which only looks at the given TypeLoc node. This patch introduces a new, and more common TypeLoc node which contains no source locations on itself. This is not an inovation here, and some other, more rare TypeLoc nodes could also have this property, but if you use getLocalSourceRange on them, it's not going to return any valid locations, because it doesn't have any. The right fix here is to always use getSourceRange() or getBeginLoc/getEndLoc which will dive into the inner TypeLoc to get the source range if it doesn't find it on the top level one. You can use getLocalSourceRange if you are really into micro-optimizations and you have some outside knowledge that the TypeLocs you are dealing with will always include some source location. 4) Exposed a bug somewhere in the use of the normal clang type class API, where you have some type, you want to see if that type is some particular kind, you try a `dyn_cast` such as `dyn_cast<TypedefType>` and that fails because now you have an ElaboratedType which has a TypeDefType inside of it, which is what you wanted to match. Again, like 2), this would usually have been tested poorly with some simple tests with no qualifications, and would have been broken had there been any other kind of type sugar, be it an ElaboratedType or a TemplateSpecializationType or a SubstTemplateParmType. The usual fix here is to use `getAs` instead of `dyn_cast`, which will look deeper into the type. Or use `getAsAdjusted` when dealing with TypeLocs. For some reason the API is inconsistent there and on TypeLocs getAs behaves like a dyn_cast. 5) It could be a bug in this patch perhaps. Let me know if you need any help! Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D112374
2021-10-11 18:15:36 +02:00
PrintTypes:
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
if (PrintTree) OS << '[';
OS << (FromDefault ? "(default) " : "");
Bold();
OS << FromTypeStr;
Unbold();
if (PrintTree) {
OS << " != " << (ToDefault ? "(default) " : "");
Bold();
OS << ToTypeStr;
Unbold();
OS << "]";
}
}
/// PrintExpr - Prints out the expr template arguments, highlighting argument
/// differences.
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
void PrintExpr(const Expr *FromExpr, const Expr *ToExpr, bool FromDefault,
bool ToDefault, bool Same) {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
assert((FromExpr || ToExpr) &&
"Only one template argument may be missing.");
if (Same) {
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
PrintExpr(FromExpr);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
} else if (!PrintTree) {
OS << (FromDefault ? "(default) " : "");
Bold();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
PrintExpr(FromExpr);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Unbold();
} else {
OS << (FromDefault ? "[(default) " : "[");
Bold();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
PrintExpr(FromExpr);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Unbold();
OS << " != " << (ToDefault ? "(default) " : "");
Bold();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
PrintExpr(ToExpr);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Unbold();
OS << ']';
}
}
/// PrintExpr - Actual formatting and printing of expressions.
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
void PrintExpr(const Expr *E) {
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 04:24:50 +00:00
if (E) {
[C++11] Use 'nullptr'. AST edition. llvm-svn: 208517
2014-05-12 05:36:57 +00:00
E->printPretty(OS, nullptr, Policy);
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 04:24:50 +00:00
return;
}
OS << "(no argument)";
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
/// PrintTemplateTemplate - Handles printing of template template arguments,
/// highlighting argument differences.
void PrintTemplateTemplate(TemplateDecl *FromTD, TemplateDecl *ToTD,
bool FromDefault, bool ToDefault, bool Same) {
assert((FromTD || ToTD) && "Only one template argument may be missing.");
When comparing two template template arguments in the template differ, consider them the same if they are actually the same; having the same name isn't enough. Similar to r174013, template template arguments were also mistakenly considered the same when they had the same name but were in different namespaces. In addition, when printing template template arguments, use the qualified name if the regular name is the same. llvm-svn: 174029
2013-01-31 02:47:46 +00:00
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-28 20:23:46 +01:00
std::string FromName =
std::string(FromTD ? FromTD->getName() : "(no argument)");
std::string ToName = std::string(ToTD ? ToTD->getName() : "(no argument)");
When comparing two template template arguments in the template differ, consider them the same if they are actually the same; having the same name isn't enough. Similar to r174013, template template arguments were also mistakenly considered the same when they had the same name but were in different namespaces. In addition, when printing template template arguments, use the qualified name if the regular name is the same. llvm-svn: 174029
2013-01-31 02:47:46 +00:00
if (FromTD && ToTD && FromName == ToName) {
FromName = FromTD->getQualifiedNameAsString();
ToName = ToTD->getQualifiedNameAsString();
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
if (Same) {
[clang][nearly-NFC] Remove some superfluous uses of NamedDecl::getNameAsString `OS << ND->getDeclName();` is equivalent to `OS << ND->getNameAsString();` without the extra temporary string. This is not quite a NFC since two uses of `getNameAsString` in a diagnostic are replaced, which results in the named entity being quoted with additional "'"s (ie: 'var' instead of var).
2020-08-05 11:48:09 +01:00
OS << "template " << FromTD->getDeclName();
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
} else if (!PrintTree) {
OS << (FromDefault ? "(default) template " : "template ");
Bold();
When comparing two template template arguments in the template differ, consider them the same if they are actually the same; having the same name isn't enough. Similar to r174013, template template arguments were also mistakenly considered the same when they had the same name but were in different namespaces. In addition, when printing template template arguments, use the qualified name if the regular name is the same. llvm-svn: 174029
2013-01-31 02:47:46 +00:00
OS << FromName;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Unbold();
} else {
OS << (FromDefault ? "[(default) template " : "[template ");
Bold();
When comparing two template template arguments in the template differ, consider them the same if they are actually the same; having the same name isn't enough. Similar to r174013, template template arguments were also mistakenly considered the same when they had the same name but were in different namespaces. In addition, when printing template template arguments, use the qualified name if the regular name is the same. llvm-svn: 174029
2013-01-31 02:47:46 +00:00
OS << FromName;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Unbold();
OS << " != " << (ToDefault ? "(default) template " : "template ");
Bold();
When comparing two template template arguments in the template differ, consider them the same if they are actually the same; having the same name isn't enough. Similar to r174013, template template arguments were also mistakenly considered the same when they had the same name but were in different namespaces. In addition, when printing template template arguments, use the qualified name if the regular name is the same. llvm-svn: 174029
2013-01-31 02:47:46 +00:00
OS << ToName;
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Unbold();
OS << ']';
}
}
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-01 21:29:28 +00:00
/// PrintAPSInt - Handles printing of integral arguments, highlighting
/// argument differences.
Apply some suggestions from clang-tidy's performance-unnecessary-value-param. No functionality change intended. llvm-svn: 272789
2016-06-15 14:20:56 +00:00
void PrintAPSInt(const llvm::APSInt &FromInt, const llvm::APSInt &ToInt,
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
bool IsValidFromInt, bool IsValidToInt, QualType FromIntType,
QualType ToIntType, Expr *FromExpr, Expr *ToExpr,
bool FromDefault, bool ToDefault, bool Same) {
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-01 21:29:28 +00:00
assert((IsValidFromInt || IsValidToInt) &&
"Only one integral argument may be missing.");
if (Same) {
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
if (FromIntType->isBooleanType()) {
OS << ((FromInt == 0) ? "false" : "true");
} else {
[ADT] Remove APInt/APSInt toString() std::string variants <string> is currently the highest impact header in a clang+llvm build: https://commondatastorage.googleapis.com/chromium-browser-clang/llvm-include-analysis.html One of the most common places this is being included is the APInt.h header, which needs it for an old toString() implementation that returns std::string - an inefficient method compared to the SmallString versions that it actually wraps. This patch replaces these APInt/APSInt methods with a pair of llvm::toString() helpers inside StringExtras.h, adjusts users accordingly and removes the <string> from APInt.h - I was hoping that more of these users could be converted to use the SmallString methods, but it appears that most end up creating a std::string anyhow. I avoided trying to use the raw_ostream << operators as well as I didn't want to lose having the integer radix explicit in the code. Differential Revision: https://reviews.llvm.org/D103888
2021-06-11 13:19:00 +01:00
OS << toString(FromInt, 10);
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
}
return;
}
bool PrintType = IsValidFromInt && IsValidToInt &&
!Context.hasSameType(FromIntType, ToIntType);
if (!PrintTree) {
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-01 21:29:28 +00:00
OS << (FromDefault ? "(default) " : "");
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-01 21:29:28 +00:00
} else {
OS << (FromDefault ? "[(default) " : "[");
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-01 21:29:28 +00:00
OS << " != " << (ToDefault ? "(default) " : "");
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
PrintAPSInt(ToInt, ToExpr, IsValidToInt, ToIntType, PrintType);
Fix the template type diffing to handle integral template arguments. llvm-svn: 167252
2012-11-01 21:29:28 +00:00
OS << ']';
}
}
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
/// PrintAPSInt - If valid, print the APSInt. If the expression is
/// gives more information, print it too.
Apply some suggestions from clang-tidy's performance-unnecessary-value-param. No functionality change intended. llvm-svn: 272789
2016-06-15 14:20:56 +00:00
void PrintAPSInt(const llvm::APSInt &Val, Expr *E, bool Valid,
QualType IntType, bool PrintType) {
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
Bold();
if (Valid) {
if (HasExtraInfo(E)) {
PrintExpr(E);
Unbold();
OS << " aka ";
Bold();
}
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
if (PrintType) {
Unbold();
OS << "(";
Bold();
IntType.print(OS, Context.getPrintingPolicy());
Unbold();
OS << ") ";
Bold();
}
if (IntType->isBooleanType()) {
OS << ((Val == 0) ? "false" : "true");
} else {
[ADT] Remove APInt/APSInt toString() std::string variants <string> is currently the highest impact header in a clang+llvm build: https://commondatastorage.googleapis.com/chromium-browser-clang/llvm-include-analysis.html One of the most common places this is being included is the APInt.h header, which needs it for an old toString() implementation that returns std::string - an inefficient method compared to the SmallString versions that it actually wraps. This patch replaces these APInt/APSInt methods with a pair of llvm::toString() helpers inside StringExtras.h, adjusts users accordingly and removes the <string> from APInt.h - I was hoping that more of these users could be converted to use the SmallString methods, but it appears that most end up creating a std::string anyhow. I avoided trying to use the raw_ostream << operators as well as I didn't want to lose having the integer radix explicit in the code. Differential Revision: https://reviews.llvm.org/D103888
2021-06-11 13:19:00 +01:00
OS << toString(Val, 10);
Save the integer type for integral template arguments. Save the integer type when diffing integers in template type diffing. When integers are different sizes, print out the type along with the integer value. Also with the type information, print true and false instead of 1 and 0 for boolean values. llvm-svn: 257861
2016-01-15 02:55:17 +00:00
}
PR15677 - Crash in template diffing. Check that expression is evaluatable before evaluating it. llvm-svn: 212090
2014-07-01 04:17:53 +00:00
} else if (E) {
PrintExpr(E);
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
} else {
OS << "(no argument)";
}
Unbold();
}
When checking the template argument list, use a copy of that list for changes and only update the orginal list on a valid arugment list. When checking an individual expression template argument, and conversions are required, update the expression in the template argument. Since template arguments are speculatively checked, the copying of the template argument list prevents updating the template arguments when the list does not match the template. Additionally, clean up the integer checking code in the template diffing code. The code performs unneccessary conversions from APSInt to APInt. Fixes PR21758. This essentially reverts r224770 to recommits r224667 and r224668 with extra changes to prevent the template instantiation problems seen in PR22006. A test to catch the discovered problem is also added. llvm-svn: 226983
2015-01-24 02:48:32 +00:00
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
/// HasExtraInfo - Returns true if E is not an integer literal, the
/// negation of an integer literal, or a boolean literal.
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
bool HasExtraInfo(Expr *E) {
if (!E) return false;
When checking the template argument list, use a copy of that list for changes and only update the orginal list on a valid arugment list. When checking an individual expression template argument, and conversions are required, update the expression in the template argument. Since template arguments are speculatively checked, the copying of the template argument list prevents updating the template arguments when the list does not match the template. Additionally, clean up the integer checking code in the template diffing code. The code performs unneccessary conversions from APSInt to APInt. Fixes PR21758. This essentially reverts r224770 to recommits r224667 and r224668 with extra changes to prevent the template instantiation problems seen in PR22006. A test to catch the discovered problem is also added. llvm-svn: 226983
2015-01-24 02:48:32 +00:00
E = E->IgnoreImpCasts();
[clang] Remove redundant integer values in template type diffing Look through SubstNonTypeTemplateParmExpr to find an IntegerLiteral node when attempting to determine if extra info is printed via the aka mechanism. This will avoid printing types such as "array<5 aka 5>" and will only show "array<5>".
2024-12-01 19:21:42 -08:00
auto CheckIntegerLiteral = [](Expr *E) {
if (auto *TemplateExpr = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
E = TemplateExpr->getReplacement();
return isa<IntegerLiteral>(E);
};
if (CheckIntegerLiteral(E)) return false;
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
if (UO->getOpcode() == UO_Minus)
[clang] Remove redundant integer values in template type diffing Look through SubstNonTypeTemplateParmExpr to find an IntegerLiteral node when attempting to determine if extra info is printed via the aka mechanism. This will avoid printing types such as "array<5 aka 5>" and will only show "array<5>".
2024-12-01 19:21:42 -08:00
if (CheckIntegerLiteral(UO->getSubExpr()))
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
return false;
Refactor template type diffing 1) Instead of using pairs of From/To* fields, combine fields into a struct TemplateArgInfo and have two in each DiffNode. 2) Use default initialization in DiffNode so that the constructor shows the only field that is initialized differently on construction. 3) Use Set and Get functions per each DiffKind to make sure all fields for the diff is set. In one case, the Expr fields were not set. 4) Don't print boolean literals for boolean template arguments. This prevents printing 'false aka 0' Only #3 has a functional change, which is reflected in the test change. llvm-svn: 257831
2016-01-14 22:56:39 +00:00
if (isa<CXXBoolLiteralExpr>(E))
return false;
Improve template diffing handling of default integer values. When the template argument is both default and value dependent, the expression retrieved for the default argument cannot be evaluated, thus never matching any argument value. To get the proper value, get the template argument from the desugared template specialization. Also, output the original expression to provide more information about the argument mismatch. llvm-svn: 177209
2013-03-15 23:55:09 +00:00
return true;
}
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
void PrintValueDecl(ValueDecl *VD, bool AddressOf, Expr *E, bool NullPtr) {
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 04:24:50 +00:00
if (VD) {
if (AddressOf)
OS << "&";
[c++20] For P0732R2 / P1907R1: Basic frontend support for class types as non-type template parameters. Create a unique TemplateParamObjectDecl instance for each such value, representing the globally unique template parameter object to which the template parameter refers. No IR generation support yet; that will follow in a separate patch.
2020-09-20 23:16:08 -07:00
else if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(VD)) {
// FIXME: Diffing the APValue would be neat.
// FIXME: Suppress this and use the full name of the declaration if the
// parameter is a pointer or reference.
Ensure we disambiguate NTTP names when doing TemplateTree comparisons 835b99e4c did this when we printed the NTTPs while NOT doing a TemplateTree comparison, this does the same change for the TemplateTree mechanism as well, amking the diagnostics less confusing in these cases. Fixes: #66744
2023-09-21 11:57:11 -07:00
TPO->getType().getUnqualifiedType().print(OS, Policy);
[AST] Print NTTP args as string-literals when possible C++20 non-type template parameter prints `MyType<{{116, 104, 105, 115}}>` when the code is as simple as `MyType<"this">`. This patch prints `MyType<{"this"}>`, with one layer of braces preserved for the intermediate structural type to trigger CTAD. `StringLiteral` handles this case, but `StringLiteral` inside `APValue` code looks like a circular dependency. The proposed patch implements a cheap strategy to emit string literals in diagnostic messages only when they are readable and fall back to integer sequences. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D115031
2022-03-01 19:33:43 -06:00
TPO->printAsInit(OS, Policy);
[c++20] For P0732R2 / P1907R1: Basic frontend support for class types as non-type template parameters. Create a unique TemplateParamObjectDecl instance for each such value, representing the globally unique template parameter object to which the template parameter refers. No IR generation support yet; that will follow in a separate patch.
2020-09-20 23:16:08 -07:00
return;
}
Properly print unnamed TagDecl objects in diagnostics The diagnostics engine is very smart about being passed a NamedDecl to print as part of a diagnostic; it gets the "right" form of the name, quotes it properly, etc. However, the result of using an unnamed tag declaration was to print '' instead of anything useful. This patch causes us to print the same information we'd have gotten if we had printed the type of the declaration rather than the name of it, as that's the most relevant information we can display. Differential Revision: https://reviews.llvm.org/D134813
2022-10-14 08:17:16 -04:00
VD->printName(OS, Policy);
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 04:24:50 +00:00
return;
}
if (NullPtr) {
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
if (E && !isa<CXXNullPtrLiteralExpr>(E)) {
PrintExpr(E);
if (IsBold) {
Unbold();
OS << " aka ";
Bold();
} else {
OS << " aka ";
}
}
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 04:24:50 +00:00
OS << "nullptr";
return;
}
[clang] add fallback to expr in the template differ when comparing ValueDecl (#93266)
2024-05-24 11:38:22 -03:00
if (E) {
PrintExpr(E);
return;
}
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 04:24:50 +00:00
OS << "(no argument)";
}
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
/// PrintDecl - Handles printing of Decl arguments, highlighting
/// argument differences.
void PrintValueDecl(ValueDecl *FromValueDecl, ValueDecl *ToValueDecl,
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 04:24:50 +00:00
bool FromAddressOf, bool ToAddressOf, bool FromNullPtr,
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
bool ToNullPtr, Expr *FromExpr, Expr *ToExpr,
bool FromDefault, bool ToDefault, bool Same) {
Add support for nullptr template arguments to template type diffing. llvm-svn: 213840
2014-07-24 04:24:50 +00:00
assert((FromValueDecl || FromNullPtr || ToValueDecl || ToNullPtr) &&
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
"Only one Decl argument may be NULL");
if (Same) {
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
} else if (!PrintTree) {
OS << (FromDefault ? "(default) " : "");
Bold();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
Unbold();
} else {
OS << (FromDefault ? "[(default) " : "[");
Bold();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
Unbold();
OS << " != " << (ToDefault ? "(default) " : "");
Bold();
Make template type diffing use the new desguared iterator. If available, use the canonical template argument to fill in information for template type diffing instead of attempting to special case and evaluate Expr's for the value. Since those are the values used in template instantiation, we don't have to worry about difference between our evaluator and theirs. Also move the nullptr template arguments from DiffKind::Expression to DiffKind::Declaration and allow DiffKind::Declaration to set an Expr. The only effect that should result is that a named nullptr will show up as 'ptr aka nullptr' in diagnostics. llvm-svn: 257853
2016-01-15 01:08:56 +00:00
PrintValueDecl(ToValueDecl, ToAddressOf, ToExpr, ToNullPtr);
Update template diffing to handle template arguments that are declarations. llvm-svn: 176153
2013-02-27 01:41:53 +00:00
Unbold();
OS << ']';
}
}
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 05:01:53 +00:00
/// PrintValueDeclAndInteger - Uses the print functions for ValueDecl and
/// APSInt to print a mixed difference.
void PrintValueDeclAndInteger(ValueDecl *VD, bool NeedAddressOf,
bool IsNullPtr, Expr *VDExpr, bool DefaultDecl,
Apply some suggestions from clang-tidy's performance-unnecessary-value-param. No functionality change intended. llvm-svn: 272789
2016-06-15 14:20:56 +00:00
const llvm::APSInt &Val, QualType IntType,
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 05:01:53 +00:00
Expr *IntExpr, bool DefaultInt) {
if (!PrintTree) {
OS << (DefaultDecl ? "(default) " : "");
Bold();
PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
Unbold();
} else {
OS << (DefaultDecl ? "[(default) " : "[");
Bold();
PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
Unbold();
OS << " != " << (DefaultInt ? "(default) " : "");
PrintAPSInt(Val, IntExpr, true /*Valid*/, IntType, false /*PrintType*/);
OS << ']';
}
}
/// PrintIntegerAndValueDecl - Uses the print functions for APSInt and
/// ValueDecl to print a mixed difference.
Apply some suggestions from clang-tidy's performance-unnecessary-value-param. No functionality change intended. llvm-svn: 272789
2016-06-15 14:20:56 +00:00
void PrintIntegerAndValueDecl(const llvm::APSInt &Val, QualType IntType,
Add new diff modes to template type diffing. Remove an old assertion that does not hold. It is possible for a template argument to be a declaration in one instantiation and an integer in another. Create two new diff kinds for these (decl vs int and int vs decl). llvm-svn: 257869
2016-01-15 05:01:53 +00:00
Expr *IntExpr, bool DefaultInt, ValueDecl *VD,
bool NeedAddressOf, bool IsNullPtr,
Expr *VDExpr, bool DefaultDecl) {
if (!PrintTree) {
OS << (DefaultInt ? "(default) " : "");
PrintAPSInt(Val, IntExpr, true /*Valid*/, IntType, false /*PrintType*/);
} else {
OS << (DefaultInt ? "[(default) " : "[");
PrintAPSInt(Val, IntExpr, true /*Valid*/, IntType, false /*PrintType*/);
OS << " != " << (DefaultDecl ? "(default) " : "");
Bold();
PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);
Unbold();
OS << ']';
}
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
// Prints the appropriate placeholder for elided template arguments.
void PrintElideArgs(unsigned NumElideArgs, unsigned Indent) {
if (PrintTree) {
OS << '\n';
for (unsigned i = 0; i < Indent; ++i)
OS << " ";
}
if (NumElideArgs == 0) return;
if (NumElideArgs == 1)
OS << "[...]";
else
OS << "[" << NumElideArgs << " * ...]";
}
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-28 20:32:51 +00:00
// Prints and highlights differences in Qualifiers.
void PrintQualifiers(Qualifiers FromQual, Qualifiers ToQual) {
// Both types have no qualifiers
if (FromQual.empty() && ToQual.empty())
return;
// Both types have same qualifiers
if (FromQual == ToQual) {
PrintQualifier(FromQual, /*ApplyBold*/false);
return;
}
// Find common qualifiers and strip them from FromQual and ToQual.
Qualifiers CommonQual = Qualifiers::removeCommonQualifiers(FromQual,
ToQual);
// The qualifiers are printed before the template name.
// Inline printing:
// The common qualifiers are printed. Then, qualifiers only in this type
// are printed and highlighted. Finally, qualifiers only in the other
// type are printed and highlighted inside parentheses after "missing".
// Tree printing:
// Qualifiers are printed next to each other, inside brackets, and
// separated by "!=". The printing order is:
// common qualifiers, highlighted from qualifiers, "!=",
// common qualifiers, highlighted to qualifiers
if (PrintTree) {
OS << "[";
if (CommonQual.empty() && FromQual.empty()) {
Bold();
OS << "(no qualifiers) ";
Unbold();
} else {
PrintQualifier(CommonQual, /*ApplyBold*/false);
PrintQualifier(FromQual, /*ApplyBold*/true);
}
OS << "!= ";
if (CommonQual.empty() && ToQual.empty()) {
Bold();
OS << "(no qualifiers)";
Unbold();
} else {
PrintQualifier(CommonQual, /*ApplyBold*/false,
/*appendSpaceIfNonEmpty*/!ToQual.empty());
PrintQualifier(ToQual, /*ApplyBold*/true,
/*appendSpaceIfNonEmpty*/false);
}
OS << "] ";
} else {
PrintQualifier(CommonQual, /*ApplyBold*/false);
PrintQualifier(FromQual, /*ApplyBold*/true);
}
}
void PrintQualifier(Qualifiers Q, bool ApplyBold,
bool AppendSpaceIfNonEmpty = true) {
if (Q.empty()) return;
if (ApplyBold) Bold();
Q.print(OS, Policy, AppendSpaceIfNonEmpty);
if (ApplyBold) Unbold();
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
public:
Push the raw_ostream through the template diffing code. llvm-svn: 175896
2013-02-22 16:08:12 +00:00
TemplateDiff(raw_ostream &OS, ASTContext &Context, QualType FromType,
QualType ToType, bool PrintTree, bool PrintFromType,
bool ElideType, bool ShowColor)
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
: Context(Context),
Policy(Context.getLangOpts()),
ElideType(ElideType),
PrintTree(PrintTree),
ShowColor(ShowColor),
// When printing a single type, the FromType is the one printed.
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 05:48:38 +00:00
FromTemplateType(PrintFromType ? FromType : ToType),
ToTemplateType(PrintFromType ? ToType : FromType),
Push the raw_ostream through the template diffing code. llvm-svn: 175896
2013-02-22 16:08:12 +00:00
OS(OS),
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
IsBold(false) {
}
/// DiffTemplate - Start the template type diffing.
void DiffTemplate() {
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 05:48:38 +00:00
Qualifiers FromQual = FromTemplateType.getQualifiers(),
ToQual = ToTemplateType.getQualifiers();
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-28 20:32:51 +00:00
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
const TemplateSpecializationType *FromOrigTST =
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 05:48:38 +00:00
GetTemplateSpecializationType(Context, FromTemplateType);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
const TemplateSpecializationType *ToOrigTST =
Fixing more issues with template type diffing 1) Print qualifiers for templates with zero arguments 2) Add a few more tests for the template type diffing refactoring. Specifically, PR24587 has been fixed and has a test case from http://reviews.llvm.org/D15384 3) Adds asserts to check the DiffTree is in correct state when moving nodes 4) Rename the field FromType and ToType since it is heavily used within member functions. llvm-svn: 257870
2016-01-15 05:48:38 +00:00
GetTemplateSpecializationType(Context, ToTemplateType);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
// Only checking templates.
if (!FromOrigTST || !ToOrigTST)
return;
// Different base templates.
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
if (!hasSameTemplate(Context, FromOrigTST, ToOrigTST)) {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
return;
}
Update template type diffing to handle qualifiers. Differing qualifiers will now be printed with highlighting. llvm-svn: 164843
2012-09-28 20:32:51 +00:00
FromQual -= QualType(FromOrigTST, 0).getQualifiers();
ToQual -= QualType(ToOrigTST, 0).getQualifiers();
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
// Same base template, but different arguments.
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
Tree.SetTemplateDiff(
FromOrigTST->getTemplateName().getAsTemplateDecl(
/*IgnoreDeduced=*/true),
ToOrigTST->getTemplateName().getAsTemplateDecl(/*IgnoreDeduced=*/true),
FromQual, ToQual, false /*FromDefault*/, false /*ToDefault*/);
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
DiffTemplate(FromOrigTST, ToOrigTST);
Remove spurious semicolons committed in r159216. llvm-svn: 159218
2012-06-26 18:52:09 +00:00
}
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Use raw_ostream::indent, update comment. llvm-svn: 175897
2013-02-22 16:13:34 +00:00
/// Emit - When the two types given are templated types with the same
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// base template, a string representation of the type difference will be
Use raw_ostream::indent, update comment. llvm-svn: 175897
2013-02-22 16:13:34 +00:00
/// emitted to the stream and return true. Otherwise, return false.
Push the raw_ostream through the template diffing code. llvm-svn: 175896
2013-02-22 16:08:12 +00:00
bool Emit() {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
Tree.StartTraverse();
if (Tree.Empty())
return false;
TreeToString();
assert(!IsBold && "Bold is applied to end of string.");
return true;
}
}; // end class TemplateDiff
Fix some Clang-tidy readability-redundant-control-flow warnings; other minor fixes. Differential revision: http://reviews.llvm.org/D17060 llvm-svn: 260414
2016-02-10 19:11:58 +00:00
} // end anonymous namespace
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
/// FormatTemplateTypeDiff - A helper static function to start the template
/// diff and return the properly formatted string. Returns true if the diff
/// is successful.
static bool FormatTemplateTypeDiff(ASTContext &Context, QualType FromType,
QualType ToType, bool PrintTree,
Remove trailing space sed -Ei 's/[[:space:]]+$//' include/**/*.{def,h,td} lib/**/*.{cpp,h} llvm-svn: 338291
2018-07-30 19:24:48 +00:00
bool PrintFromType, bool ElideType,
Push the raw_ostream through the template diffing code. llvm-svn: 175896
2013-02-22 16:08:12 +00:00
bool ShowColors, raw_ostream &OS) {
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
if (PrintTree)
PrintFromType = true;
Push the raw_ostream through the template diffing code. llvm-svn: 175896
2013-02-22 16:08:12 +00:00
TemplateDiff TD(OS, Context, FromType, ToType, PrintTree, PrintFromType,
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
ElideType, ShowColors);
TD.DiffTemplate();
Push the raw_ostream through the template diffing code. llvm-svn: 175896
2013-02-22 16:08:12 +00:00
return TD.Emit();
Add template type diffing to Clang. This feature will provide a better comparison between two templated types when they both appear in a diagnostic. Type elision will remove indentical template arguments, which can be disabled with -fno-elide-type. Cyan highlighting is applied to the differing types. For more formatting, -fdiagnostic-show-template-tree will output the template type as an indented text tree, with differences appearing inline. Template tree works with or without type elision. llvm-svn: 159216
2012-06-26 18:18:47 +00:00
}
Reference in New Issue Copy Permalink