mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-29 15:56:06 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/clang/lib/AST/TemplateName.cpp

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

501 lines
18 KiB
C++
Raw Normal View History

[AST] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 318813
2017-11-21 23:26:08 +00:00
//===- TemplateName.cpp - C++ Template Name Representation ----------------===//
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
//
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
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
//
//===----------------------------------------------------------------------===//
//
// This file defines the TemplateName interface and subclasses.
//
//===----------------------------------------------------------------------===//
add TemplateName.cpp/h to the xcode project, minor tidying. llvm-svn: 68301
2009-04-02 06:07:12 +00:00
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
#include "clang/AST/TemplateName.h"
[AST] Refactor propagation of dependency bits. NFC Summary: This changes introduces an enum to represent dependencies as a bitmask and extract common patterns from code that computes dependency bits into helper functions. Reviewers: rsmith, martong, shafik, ilya-biryukov, hokein Subscribers: hokein, sammccall, Mordante, riccibruno, merge_guards_bot, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71920
2020-03-02 16:07:09 +01:00
#include "clang/AST/Decl.h"
[AST] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 318813
2017-11-21 23:26:08 +00:00
#include "clang/AST/DeclBase.h"
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02:00
#include "clang/AST/DeclCXX.h"
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
#include "clang/AST/DeclTemplate.h"
[AST] rename DependencyFlags.h => DependenceFlags.h, NFC We forgot to fix in the previous patch.
2020-03-16 13:43:40 +01:00
#include "clang/AST/DependenceFlags.h"
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
#include "clang/AST/NestedNameSpecifier.h"
Create a new PrintingPolicy class, which we pass down through the AST printing logic to help customize the output. For now, we use this rather than a special flag to suppress the "struct" when printing "struct X" and to print the Boolean type as "bool" in C++ but "_Bool" in C. llvm-svn: 72590
2009-05-29 20:38:28 +00:00
#include "clang/AST/PrettyPrinter.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/TemplateBase.h"
When a template (without arguments) is passed as a template type parameter, explicitly ask the user to give it arguments. We used to complain that it wasn't a type and expect the user to figure it out. llvm-svn: 100729
2010-04-08 00:03:06 +00:00
#include "clang/Basic/Diagnostic.h"
[AST] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 318813
2017-11-21 23:26:08 +00:00
#include "clang/Basic/LLVM.h"
Key decisions about 'bool' vs '_Bool' to be based on a new flag in langoptions. This is simple enough, but then I thought it would be nice to make PrintingPolicy get a LangOptions so that various things can key off "bool" and "C++" independently. This spiraled out of control. There are many fixme's, but I think things are slightly better than they were before. One thing that can be improved: CFG should probably have an ASTContext pointer in it, which would simplify its clients. llvm-svn: 74493
2009-06-30 01:26:17 +00:00
#include "clang/Basic/LangOptions.h"
[AST] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 318813
2017-11-21 23:26:08 +00:00
#include "clang/Basic/OperatorKinds.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/Support/Compiler.h"
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
#include "llvm/Support/raw_ostream.h"
[AST] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 318813
2017-11-21 23:26:08 +00:00
#include <cassert>
[clang] Add #include <optional> (NFC) This patch adds #include <optional> to those files containing llvm::Optional<...> or Optional<...>. I'll post a separate patch to actually replace llvm::Optional with std::optional. This is part of an effort to migrate from llvm::Optional to std::optional: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716
2023-01-14 11:07:21 -08:00
#include <optional>
[AST] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 318813
2017-11-21 23:26:08 +00:00
#include <string>
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
using namespace clang;
[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
DeducedTemplateStorage::DeducedTemplateStorage(TemplateName Underlying,
const DefaultArguments &DefArgs)
: UncommonTemplateNameStorage(Deduced, /*Index=*/DefArgs.StartPos,
DefArgs.Args.size()),
Underlying(Underlying) {
llvm::copy(DefArgs.Args, reinterpret_cast<TemplateArgument *>(this + 1));
}
void DeducedTemplateStorage::Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context) const {
Profile(ID, Context, Underlying, getDefaultArguments());
}
void DeducedTemplateStorage::Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
TemplateName Underlying,
const DefaultArguments &DefArgs) {
Underlying.Profile(ID);
ID.AddInteger(DefArgs.StartPos);
ID.AddInteger(DefArgs.Args.size());
for (const TemplateArgument &Arg : DefArgs.Args)
Arg.Profile(ID, Context);
}
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
TemplateArgument
Introduce a new kind of TemplateName that captures a substituted template template parameter pack that cannot be fully expanded because its enclosing pack expansion could not be expanded. This form of TemplateName plays the same role as SubstTemplateTypeParmPackType and SubstNonTypeTemplateParmPackExpr do for template type parameter packs and non-type template parameter packs, respectively. We should now handle these multi-level pack expansion substitutions anywhere. The largest remaining gap in our variadic-templates support is that we cannot cope with non-type template parameter packs whose type is a pack expansion. llvm-svn: 123521
2011-01-15 06:45:20 +00:00
SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
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
return TemplateArgument(llvm::ArrayRef(Arguments, Bits.Data));
[clang] Track the templated entity in type substitution. This is a change to how we represent type subsitution in the AST. Instead of only storing the replaced type, we track the templated entity we are substituting, plus an index. We modify MLTAL to track the templated entity at each level. Otherwise, it's much more expensive to go from the template parameter back to the templated entity, and not possible to do in some cases, as when we instantiate outer templates, parameters might still reference the original entity. This also allows us to very cheaply lookup the templated entity we saw in the naming context and find the corresponding argument it was replaced from, such as for implementing template specialization resugaring. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D131858
2022-08-14 13:48:18 +02:00
}
TemplateTemplateParmDecl *
SubstTemplateTemplateParmPackStorage::getParameterPack() const {
return cast<TemplateTemplateParmDecl>(
getReplacedTemplateParameterList(getAssociatedDecl())
->asArray()[Bits.Index]);
}
TemplateTemplateParmDecl *
SubstTemplateTemplateParmStorage::getParameter() const {
return cast<TemplateTemplateParmDecl>(
getReplacedTemplateParameterList(getAssociatedDecl())
->asArray()[Bits.Index]);
Introduce a new kind of TemplateName that captures a substituted template template parameter pack that cannot be fully expanded because its enclosing pack expansion could not be expanded. This form of TemplateName plays the same role as SubstTemplateTypeParmPackType and SubstNonTypeTemplateParmPackExpr do for template type parameter packs and non-type template parameter packs, respectively. We should now handle these multi-level pack expansion substitutions anywhere. The largest remaining gap in our variadic-templates support is that we cannot cope with non-type template parameter packs whose type is a pack expansion. llvm-svn: 123521
2011-01-15 06:45:20 +00:00
}
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 08:33:18 +00:00
void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) {
[clang] Track final substitution for Subst* AST nodes (#132748)
2025-04-02 19:27:29 -03:00
Profile(ID, Replacement, getAssociatedDecl(), getIndex(), getPackIndex(),
getFinal());
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 08:33:18 +00:00
}
[clang] Use std::optional instead of llvm::Optional (NFC) This patch replaces (llvm::|)Optional< with std::optional<. I'll post a separate patch to remove #include "llvm/ADT/Optional.h". This is part of an effort to migrate from llvm::Optional to std::optional: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716
2023-01-14 12:31:01 -08:00
void SubstTemplateTemplateParmStorage::Profile(
llvm::FoldingSetNodeID &ID, TemplateName Replacement, Decl *AssociatedDecl,
[clang] NFC: introduce UnsignedOrNone as a replacement for std::optional<unsigned> (#134142) This introduces a new class 'UnsignedOrNone', which models a lite version of `std::optional<unsigned>`, but has the same size as 'unsigned'. This replaces most uses of `std::optional<unsigned>`, and similar schemes utilizing 'int' and '-1' as sentinel. Besides the smaller size advantage, this is simpler to serialize, as its internal representation is a single unsigned int as well.
2025-04-03 14:27:18 -03:00
unsigned Index, UnsignedOrNone PackIndex, bool Final) {
[clang] Track the templated entity in type substitution. This is a change to how we represent type subsitution in the AST. Instead of only storing the replaced type, we track the templated entity we are substituting, plus an index. We modify MLTAL to track the templated entity at each level. Otherwise, it's much more expensive to go from the template parameter back to the templated entity, and not possible to do in some cases, as when we instantiate outer templates, parameters might still reference the original entity. This also allows us to very cheaply lookup the templated entity we saw in the naming context and find the corresponding argument it was replaced from, such as for implementing template specialization resugaring. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D131858
2022-08-14 13:48:18 +02:00
Replacement.Profile(ID);
ID.AddPointer(AssociatedDecl);
ID.AddInteger(Index);
[clang] NFC: introduce UnsignedOrNone as a replacement for std::optional<unsigned> (#134142) This introduces a new class 'UnsignedOrNone', which models a lite version of `std::optional<unsigned>`, but has the same size as 'unsigned'. This replaces most uses of `std::optional<unsigned>`, and similar schemes utilizing 'int' and '-1' as sentinel. Besides the smaller size advantage, this is simpler to serialize, as its internal representation is a single unsigned int as well.
2025-04-03 14:27:18 -03:00
ID.AddInteger(PackIndex.toInternalRepresentation());
[clang] Track final substitution for Subst* AST nodes (#132748)
2025-04-02 19:27:29 -03:00
ID.AddBoolean(Final);
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 08:33:18 +00:00
}
[clang] Implement sugared substitution changes to infrastructure Implements the changes required to perform substitution with non-canonical template arguments, and to 'finalize' them by not placing 'Subst' nodes. A finalized substitution means we won't resugar them later, because these templates themselves were eagerly substituted with the intended arguments at the point of use. We may still resugar other templates used within those, though. This patch does not actually implement any uses of this functionality, those will be added in subsequent patches, so expect no changes to existing tests. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D134604
2022-09-25 17:18:39 +02:00
SubstTemplateTemplateParmPackStorage::SubstTemplateTemplateParmPackStorage(
ArrayRef<TemplateArgument> ArgPack, Decl *AssociatedDecl, unsigned Index,
bool Final)
: UncommonTemplateNameStorage(SubstTemplateTemplateParmPack, Index,
ArgPack.size()),
Arguments(ArgPack.data()), AssociatedDeclAndFinal(AssociatedDecl, Final) {
assert(AssociatedDecl != nullptr);
}
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 08:33:18 +00:00
void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
ASTContext &Context) {
[clang] Implement sugared substitution changes to infrastructure Implements the changes required to perform substitution with non-canonical template arguments, and to 'finalize' them by not placing 'Subst' nodes. A finalized substitution means we won't resugar them later, because these templates themselves were eagerly substituted with the intended arguments at the point of use. We may still resugar other templates used within those, though. This patch does not actually implement any uses of this functionality, those will be added in subsequent patches, so expect no changes to existing tests. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D134604
2022-09-25 17:18:39 +02:00
Profile(ID, Context, getArgumentPack(), getAssociatedDecl(), getIndex(),
getFinal());
}
Decl *SubstTemplateTemplateParmPackStorage::getAssociatedDecl() const {
return AssociatedDeclAndFinal.getPointer();
}
bool SubstTemplateTemplateParmPackStorage::getFinal() const {
return AssociatedDeclAndFinal.getInt();
Introduce a new kind of TemplateName that captures a substituted template template parameter pack that cannot be fully expanded because its enclosing pack expansion could not be expanded. This form of TemplateName plays the same role as SubstTemplateTypeParmPackType and SubstNonTypeTemplateParmPackExpr do for template type parameter packs and non-type template parameter packs, respectively. We should now handle these multi-level pack expansion substitutions anywhere. The largest remaining gap in our variadic-templates support is that we cannot cope with non-type template parameter packs whose type is a pack expansion. llvm-svn: 123521
2011-01-15 06:45:20 +00:00
}
[clang] Track the templated entity in type substitution. This is a change to how we represent type subsitution in the AST. Instead of only storing the replaced type, we track the templated entity we are substituting, plus an index. We modify MLTAL to track the templated entity at each level. Otherwise, it's much more expensive to go from the template parameter back to the templated entity, and not possible to do in some cases, as when we instantiate outer templates, parameters might still reference the original entity. This also allows us to very cheaply lookup the templated entity we saw in the naming context and find the corresponding argument it was replaced from, such as for implementing template specialization resugaring. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D131858
2022-08-14 13:48:18 +02:00
void SubstTemplateTemplateParmPackStorage::Profile(
llvm::FoldingSetNodeID &ID, ASTContext &Context,
[clang] Implement sugared substitution changes to infrastructure Implements the changes required to perform substitution with non-canonical template arguments, and to 'finalize' them by not placing 'Subst' nodes. A finalized substitution means we won't resugar them later, because these templates themselves were eagerly substituted with the intended arguments at the point of use. We may still resugar other templates used within those, though. This patch does not actually implement any uses of this functionality, those will be added in subsequent patches, so expect no changes to existing tests. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D134604
2022-09-25 17:18:39 +02:00
const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index,
bool Final) {
Introduce a new kind of TemplateName that captures a substituted template template parameter pack that cannot be fully expanded because its enclosing pack expansion could not be expanded. This form of TemplateName plays the same role as SubstTemplateTypeParmPackType and SubstNonTypeTemplateParmPackExpr do for template type parameter packs and non-type template parameter packs, respectively. We should now handle these multi-level pack expansion substitutions anywhere. The largest remaining gap in our variadic-templates support is that we cannot cope with non-type template parameter packs whose type is a pack expansion. llvm-svn: 123521
2011-01-15 06:45:20 +00:00
ArgPack.Profile(ID, Context);
[clang] Track the templated entity in type substitution. This is a change to how we represent type subsitution in the AST. Instead of only storing the replaced type, we track the templated entity we are substituting, plus an index. We modify MLTAL to track the templated entity at each level. Otherwise, it's much more expensive to go from the template parameter back to the templated entity, and not possible to do in some cases, as when we instantiate outer templates, parameters might still reference the original entity. This also allows us to very cheaply lookup the templated entity we saw in the naming context and find the corresponding argument it was replaced from, such as for implementing template specialization resugaring. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D131858
2022-08-14 13:48:18 +02:00
ID.AddPointer(AssociatedDecl);
ID.AddInteger(Index);
[clang] Implement sugared substitution changes to infrastructure Implements the changes required to perform substitution with non-canonical template arguments, and to 'finalize' them by not placing 'Subst' nodes. A finalized substitution means we won't resugar them later, because these templates themselves were eagerly substituted with the intended arguments at the point of use. We may still resugar other templates used within those, though. This patch does not actually implement any uses of this functionality, those will be added in subsequent patches, so expect no changes to existing tests. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D134604
2022-09-25 17:18:39 +02:00
ID.AddBoolean(Final);
Introduce a new kind of TemplateName that captures a substituted template template parameter pack that cannot be fully expanded because its enclosing pack expansion could not be expanded. This form of TemplateName plays the same role as SubstTemplateTypeParmPackType and SubstNonTypeTemplateParmPackExpr do for template type parameter packs and non-type template parameter packs, respectively. We should now handle these multi-level pack expansion substitutions anywhere. The largest remaining gap in our variadic-templates support is that we cannot cope with non-type template parameter packs whose type is a pack expansion. llvm-svn: 123521
2011-01-15 06:45:20 +00:00
}
[clang] improved preservation of template keyword (#133610)
2025-04-01 17:15:18 -03:00
IdentifierOrOverloadedOperator::IdentifierOrOverloadedOperator(
const IdentifierInfo *II)
: PtrOrOp(reinterpret_cast<uintptr_t>(II)) {
static_assert(NUM_OVERLOADED_OPERATORS <= 4096,
"NUM_OVERLOADED_OPERATORS is too large");
assert(II);
assert(getIdentifier() == II);
}
IdentifierOrOverloadedOperator::IdentifierOrOverloadedOperator(
OverloadedOperatorKind OOK)
: PtrOrOp(-uintptr_t(OOK)) {
assert(OOK != OO_None);
assert(getOperator() == OOK);
}
void IdentifierOrOverloadedOperator::Profile(llvm::FoldingSetNodeID &ID) const {
if (auto *Identifier = getIdentifier()) {
ID.AddBoolean(false);
ID.AddPointer(Identifier);
} else {
ID.AddBoolean(true);
ID.AddInteger(getOperator());
}
}
[ptr-traits] Some compilers (older Clang? unsure) on build bots need this constructor to be out of line in order to not require the complete type of TemplateDecl. Hopefully this will fix the build bots. llvm-svn: 256629
2015-12-30 06:21:02 +00:00
TemplateName::TemplateName(void *Ptr) {
Storage = StorageType::getFromOpaqueValue(Ptr);
}
[ptr-traits] Move methods manipulating PointerUnions, DenseMap pointer keys, and PointerIntPairs where the pointee types are incomplete out-of-line to where we have the complete type. This is the standard pattern used throughout the AST library to address the inherently mutually cross referenced nature of the AST. This is part of a series of patches to allow LLVM to check for complete pointee types when computing its pointer traits. This is absolutely necessary to get correct (or reproducible) results for things like how many low bits are guaranteed to be zero. llvm-svn: 256612
2015-12-30 03:24:14 +00:00
TemplateName::TemplateName(TemplateDecl *Template) : Storage(Template) {}
TemplateName::TemplateName(OverloadedTemplateStorage *Storage)
: Storage(Storage) {}
[c++20] Implement P0846R0: allow (ADL-only) calls to template-ids whose template name is not visible to unqualified lookup. In order to support this without a severe degradation in our ability to diagnose typos in template names, this change significantly restructures the way we handle template-id-shaped syntax for which lookup of the template name finds nothing. Instead of eagerly diagnosing an undeclared template name, we now form a placeholder template-name representing a name that is known to not find any templates. When the parser sees such a name, it attempts to disambiguate whether we have a less-than comparison or a template-id. Any diagnostics or typo-correction for the name are delayed until its point of use. The upshot should be a small improvement of our diagostic quality overall: we now take more syntactic context into account when trying to resolve an undeclared identifier on the left hand side of a '<'. In fact, this works well enough that the backwards-compatible portion (for an undeclared identifier rather than a lookup that finds functions but no function templates) is enabled in all language modes. llvm-svn: 360308
2019-05-09 03:31:27 +00:00
TemplateName::TemplateName(AssumedTemplateStorage *Storage)
: Storage(Storage) {}
[ptr-traits] Move methods manipulating PointerUnions, DenseMap pointer keys, and PointerIntPairs where the pointee types are incomplete out-of-line to where we have the complete type. This is the standard pattern used throughout the AST library to address the inherently mutually cross referenced nature of the AST. This is part of a series of patches to allow LLVM to check for complete pointee types when computing its pointer traits. This is absolutely necessary to get correct (or reproducible) results for things like how many low bits are guaranteed to be zero. llvm-svn: 256612
2015-12-30 03:24:14 +00:00
TemplateName::TemplateName(SubstTemplateTemplateParmStorage *Storage)
: Storage(Storage) {}
TemplateName::TemplateName(SubstTemplateTemplateParmPackStorage *Storage)
: Storage(Storage) {}
TemplateName::TemplateName(QualifiedTemplateName *Qual) : Storage(Qual) {}
TemplateName::TemplateName(DependentTemplateName *Dep) : Storage(Dep) {}
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02:00
TemplateName::TemplateName(UsingShadowDecl *Using) : Storage(Using) {}
[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
TemplateName::TemplateName(DeducedTemplateStorage *Deduced)
: Storage(Deduced) {}
[ptr-traits] Move methods manipulating PointerUnions, DenseMap pointer keys, and PointerIntPairs where the pointee types are incomplete out-of-line to where we have the complete type. This is the standard pattern used throughout the AST library to address the inherently mutually cross referenced nature of the AST. This is part of a series of patches to allow LLVM to check for complete pointee types when computing its pointer traits. This is absolutely necessary to get correct (or reproducible) results for things like how many low bits are guaranteed to be zero. llvm-svn: 256612
2015-12-30 03:24:14 +00:00
bool TemplateName::isNull() const { return Storage.isNull(); }
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-19 19:28:53 +00:00
TemplateName::NameKind TemplateName::getKind() const {
[AST] Migrate away from PointerUnion::dyn_cast (NFC) (#125335) Note that PointerUnion::dyn_cast has been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> Literal migration would result in dyn_cast_if_present (see the definition of PointerUnion::dyn_cast), but this patch uses dyn_cast because we expect InVectors.front() and P to be nonnull.
2025-02-01 08:13:20 -08:00
if (auto *ND = dyn_cast<Decl *>(Storage)) {
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02:00
if (isa<UsingShadowDecl>(ND))
return UsingTemplate;
assert(isa<TemplateDecl>(ND));
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-19 19:28:53 +00:00
return Template;
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02:00
}
[AST] Migrate away from PointerUnion::{is,get} (NFC) (#117469) Note that PointerUnion::{is,get} have been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> I'm not touching PointerUnion::dyn_cast for now because it's a bit complicated; we could blindly migrate it to dyn_cast_if_present, but we should probably use dyn_cast when the operand is known to be non-null.
2024-11-24 07:28:20 -08:00
if (isa<DependentTemplateName *>(Storage))
Introduce a new kind of TemplateName that captures a substituted template template parameter pack that cannot be fully expanded because its enclosing pack expansion could not be expanded. This form of TemplateName plays the same role as SubstTemplateTypeParmPackType and SubstNonTypeTemplateParmPackExpr do for template type parameter packs and non-type template parameter packs, respectively. We should now handle these multi-level pack expansion substitutions anywhere. The largest remaining gap in our variadic-templates support is that we cannot cope with non-type template parameter packs whose type is a pack expansion. llvm-svn: 123521
2011-01-15 06:45:20 +00:00
return DependentTemplate;
[AST] Migrate away from PointerUnion::{is,get} (NFC) (#117469) Note that PointerUnion::{is,get} have been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> I'm not touching PointerUnion::dyn_cast for now because it's a bit complicated; we could blindly migrate it to dyn_cast_if_present, but we should probably use dyn_cast when the operand is known to be non-null.
2024-11-24 07:28:20 -08:00
if (isa<QualifiedTemplateName *>(Storage))
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-19 19:28:53 +00:00
return QualifiedTemplate;
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 08:33:18 +00:00
[AST] Migrate away from PointerUnion::{is,get} (NFC) (#117469) Note that PointerUnion::{is,get} have been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> I'm not touching PointerUnion::dyn_cast for now because it's a bit complicated; we could blindly migrate it to dyn_cast_if_present, but we should probably use dyn_cast when the operand is known to be non-null.
2024-11-24 07:28:20 -08:00
UncommonTemplateNameStorage *uncommon =
cast<UncommonTemplateNameStorage *>(Storage);
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 08:33:18 +00:00
if (uncommon->getAsOverloadedStorage())
return OverloadedTemplate;
[c++20] Implement P0846R0: allow (ADL-only) calls to template-ids whose template name is not visible to unqualified lookup. In order to support this without a severe degradation in our ability to diagnose typos in template names, this change significantly restructures the way we handle template-id-shaped syntax for which lookup of the template name finds nothing. Instead of eagerly diagnosing an undeclared template name, we now form a placeholder template-name representing a name that is known to not find any templates. When the parser sees such a name, it attempts to disambiguate whether we have a less-than comparison or a template-id. Any diagnostics or typo-correction for the name are delayed until its point of use. The upshot should be a small improvement of our diagostic quality overall: we now take more syntactic context into account when trying to resolve an undeclared identifier on the left hand side of a '<'. In fact, this works well enough that the backwards-compatible portion (for an undeclared identifier rather than a lookup that finds functions but no function templates) is enabled in all language modes. llvm-svn: 360308
2019-05-09 03:31:27 +00:00
if (uncommon->getAsAssumedTemplateName())
return AssumedTemplate;
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 08:33:18 +00:00
if (uncommon->getAsSubstTemplateTemplateParm())
return SubstTemplateTemplateParm;
[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 (uncommon->getAsDeducedTemplateName())
return DeducedTemplate;
assert(uncommon->getAsSubstTemplateTemplateParmPack() != nullptr);
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 08:33:18 +00:00
return SubstTemplateTemplateParmPack;
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-19 19:28:53 +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
TemplateDecl *TemplateName::getAsTemplateDecl(bool IgnoreDeduced) const {
TemplateName Name = *this;
while (std::optional<TemplateName> UnderlyingOrNone =
Name.desugar(IgnoreDeduced))
Name = *UnderlyingOrNone;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 15:08:12 +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
if (!IgnoreDeduced)
assert(Name.getAsDeducedTemplateName() == nullptr &&
"Unexpected canonical DeducedTemplateName; Did you mean to use "
"getTemplateDeclAndDefaultArgs instead?");
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
[clang] Migrate away from PointerUnion::dyn_cast (NFC) (#124425) Note that PointerUnion::dyn_cast has been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> This patch migrates uses of PointerUnion::dyn_cast to dyn_cast_if_present (see the definition of PointerUnion::dyn_cast). Note that we cannot use dyn_cast in any of the migrations in this patch; placing assert(!X.isNull()); just before any of dyn_cast_if_present in this patch triggers some failure in check-clang.
2025-01-25 14:05:01 -08:00
return cast_if_present<TemplateDecl>(
dyn_cast_if_present<Decl *>(Name.Storage));
[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
}
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 08:33:18 +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
std::pair<TemplateDecl *, DefaultArguments>
TemplateName::getTemplateDeclAndDefaultArgs() const {
for (TemplateName Name = *this; /**/; /**/) {
if (Name.getKind() == TemplateName::DeducedTemplate) {
DeducedTemplateStorage *DTS = Name.getAsDeducedTemplateName();
TemplateDecl *TD =
DTS->getUnderlying().getAsTemplateDecl(/*IgnoreDeduced=*/true);
DefaultArguments DefArgs = DTS->getDefaultArguments();
if (TD && DefArgs)
assert(DefArgs.StartPos + DefArgs.Args.size() <=
TD->getTemplateParameters()->size());
return {TD, DTS->getDefaultArguments()};
}
if (std::optional<TemplateName> UnderlyingOrNone =
Name.desugar(/*IgnoreDeduced=*/false)) {
Name = *UnderlyingOrNone;
continue;
}
return {cast_if_present<TemplateDecl>(Name.Storage.dyn_cast<Decl *>()), {}};
}
}
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02: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
std::optional<TemplateName> TemplateName::desugar(bool IgnoreDeduced) const {
[clang] Migrate away from PointerUnion::dyn_cast (NFC) (#124425) Note that PointerUnion::dyn_cast has been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> This patch migrates uses of PointerUnion::dyn_cast to dyn_cast_if_present (see the definition of PointerUnion::dyn_cast). Note that we cannot use dyn_cast in any of the migrations in this patch; placing assert(!X.isNull()); just before any of dyn_cast_if_present in this patch triggers some failure in check-clang.
2025-01-25 14:05:01 -08:00
if (Decl *D = dyn_cast_if_present<Decl *>(Storage)) {
[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 (auto *USD = dyn_cast<UsingShadowDecl>(D))
return TemplateName(USD->getTargetDecl());
return std::nullopt;
}
if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
return QTN->getUnderlyingTemplate();
if (SubstTemplateTemplateParmStorage *S = getAsSubstTemplateTemplateParm())
return S->getReplacement();
if (IgnoreDeduced)
if (DeducedTemplateStorage *S = getAsDeducedTemplateName())
return S->getUnderlying();
return std::nullopt;
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
}
[ptr-traits] Move methods manipulating PointerUnions, DenseMap pointer keys, and PointerIntPairs where the pointee types are incomplete out-of-line to where we have the complete type. This is the standard pattern used throughout the AST library to address the inherently mutually cross referenced nature of the AST. This is part of a series of patches to allow LLVM to check for complete pointee types when computing its pointer traits. This is absolutely necessary to get correct (or reproducible) results for things like how many low bits are guaranteed to be zero. llvm-svn: 256612
2015-12-30 03:24:14 +00:00
OverloadedTemplateStorage *TemplateName::getAsOverloadedTemplate() const {
if (UncommonTemplateNameStorage *Uncommon =
Storage.dyn_cast<UncommonTemplateNameStorage *>())
return Uncommon->getAsOverloadedStorage();
return nullptr;
}
[c++20] Implement P0846R0: allow (ADL-only) calls to template-ids whose template name is not visible to unqualified lookup. In order to support this without a severe degradation in our ability to diagnose typos in template names, this change significantly restructures the way we handle template-id-shaped syntax for which lookup of the template name finds nothing. Instead of eagerly diagnosing an undeclared template name, we now form a placeholder template-name representing a name that is known to not find any templates. When the parser sees such a name, it attempts to disambiguate whether we have a less-than comparison or a template-id. Any diagnostics or typo-correction for the name are delayed until its point of use. The upshot should be a small improvement of our diagostic quality overall: we now take more syntactic context into account when trying to resolve an undeclared identifier on the left hand side of a '<'. In fact, this works well enough that the backwards-compatible portion (for an undeclared identifier rather than a lookup that finds functions but no function templates) is enabled in all language modes. llvm-svn: 360308
2019-05-09 03:31:27 +00:00
AssumedTemplateStorage *TemplateName::getAsAssumedTemplateName() const {
if (UncommonTemplateNameStorage *Uncommon =
Storage.dyn_cast<UncommonTemplateNameStorage *>())
return Uncommon->getAsAssumedTemplateName();
return nullptr;
}
[ptr-traits] Move methods manipulating PointerUnions, DenseMap pointer keys, and PointerIntPairs where the pointee types are incomplete out-of-line to where we have the complete type. This is the standard pattern used throughout the AST library to address the inherently mutually cross referenced nature of the AST. This is part of a series of patches to allow LLVM to check for complete pointee types when computing its pointer traits. This is absolutely necessary to get correct (or reproducible) results for things like how many low bits are guaranteed to be zero. llvm-svn: 256612
2015-12-30 03:24:14 +00:00
SubstTemplateTemplateParmStorage *
TemplateName::getAsSubstTemplateTemplateParm() const {
if (UncommonTemplateNameStorage *uncommon =
[clang] Migrate away from PointerUnion::dyn_cast (NFC) (#124425) Note that PointerUnion::dyn_cast has been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> This patch migrates uses of PointerUnion::dyn_cast to dyn_cast_if_present (see the definition of PointerUnion::dyn_cast). Note that we cannot use dyn_cast in any of the migrations in this patch; placing assert(!X.isNull()); just before any of dyn_cast_if_present in this patch triggers some failure in check-clang.
2025-01-25 14:05:01 -08:00
dyn_cast_if_present<UncommonTemplateNameStorage *>(Storage))
[ptr-traits] Move methods manipulating PointerUnions, DenseMap pointer keys, and PointerIntPairs where the pointee types are incomplete out-of-line to where we have the complete type. This is the standard pattern used throughout the AST library to address the inherently mutually cross referenced nature of the AST. This is part of a series of patches to allow LLVM to check for complete pointee types when computing its pointer traits. This is absolutely necessary to get correct (or reproducible) results for things like how many low bits are guaranteed to be zero. llvm-svn: 256612
2015-12-30 03:24:14 +00:00
return uncommon->getAsSubstTemplateTemplateParm();
return nullptr;
}
SubstTemplateTemplateParmPackStorage *
TemplateName::getAsSubstTemplateTemplateParmPack() const {
if (UncommonTemplateNameStorage *Uncommon =
Storage.dyn_cast<UncommonTemplateNameStorage *>())
return Uncommon->getAsSubstTemplateTemplateParmPack();
return nullptr;
}
QualifiedTemplateName *TemplateName::getAsQualifiedTemplateName() const {
[clang] Migrate away from PointerUnion::dyn_cast (NFC) (#124425) Note that PointerUnion::dyn_cast has been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> This patch migrates uses of PointerUnion::dyn_cast to dyn_cast_if_present (see the definition of PointerUnion::dyn_cast). Note that we cannot use dyn_cast in any of the migrations in this patch; placing assert(!X.isNull()); just before any of dyn_cast_if_present in this patch triggers some failure in check-clang.
2025-01-25 14:05:01 -08:00
return dyn_cast_if_present<QualifiedTemplateName *>(Storage);
[ptr-traits] Move methods manipulating PointerUnions, DenseMap pointer keys, and PointerIntPairs where the pointee types are incomplete out-of-line to where we have the complete type. This is the standard pattern used throughout the AST library to address the inherently mutually cross referenced nature of the AST. This is part of a series of patches to allow LLVM to check for complete pointee types when computing its pointer traits. This is absolutely necessary to get correct (or reproducible) results for things like how many low bits are guaranteed to be zero. llvm-svn: 256612
2015-12-30 03:24:14 +00:00
}
DependentTemplateName *TemplateName::getAsDependentTemplateName() const {
return Storage.dyn_cast<DependentTemplateName *>();
}
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02:00
UsingShadowDecl *TemplateName::getAsUsingShadowDecl() const {
if (Decl *D = Storage.dyn_cast<Decl *>())
if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D))
return USD;
[AST] Consider QualifiedTemplateName in TemplateName::getAsUsingDecl(). If the underlying template name of a qualified template name is a using decl, TemplateName::getAsUsingDecl() will return it. This will make the UsingTemplateName consumer life easier. Differential Revision: https://reviews.llvm.org/D124437
2022-04-26 09:34:46 +02:00
if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
return QTN->getUnderlyingTemplate().getAsUsingShadowDecl();
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02:00
return nullptr;
}
[clang] improved preservation of template keyword (#133610)
2025-04-01 17:15:18 -03:00
DependentTemplateStorage::DependentTemplateStorage(
NestedNameSpecifier *Qualifier, IdentifierOrOverloadedOperator Name,
bool HasTemplateKeyword)
: Qualifier(Qualifier, HasTemplateKeyword), Name(Name) {
assert((!Qualifier || Qualifier->isDependent()) &&
"Qualifier must be dependent");
}
TemplateNameDependence DependentTemplateStorage::getDependence() const {
auto D = TemplateNameDependence::DependentInstantiation;
if (NestedNameSpecifier *Qualifier = getQualifier())
D |= toTemplateNameDependence(Qualifier->getDependence());
return D;
}
void DependentTemplateStorage::print(raw_ostream &OS,
const PrintingPolicy &Policy) const {
if (NestedNameSpecifier *NNS = getQualifier())
NNS->print(OS, Policy);
if (hasTemplateKeyword())
OS << "template ";
IdentifierOrOverloadedOperator Name = getName();
if (const IdentifierInfo *II = Name.getIdentifier())
OS << II->getName();
else
OS << "operator " << getOperatorSpelling(Name.getOperator());
}
[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
DeducedTemplateStorage *TemplateName::getAsDeducedTemplateName() const {
if (UncommonTemplateNameStorage *Uncommon =
[clang] Migrate away from PointerUnion::dyn_cast (NFC) (#124425) Note that PointerUnion::dyn_cast has been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> This patch migrates uses of PointerUnion::dyn_cast to dyn_cast_if_present (see the definition of PointerUnion::dyn_cast). Note that we cannot use dyn_cast in any of the migrations in this patch; placing assert(!X.isNull()); just before any of dyn_cast_if_present in this patch triggers some failure in check-clang.
2025-01-25 14:05:01 -08:00
dyn_cast_if_present<UncommonTemplateNameStorage *>(Storage))
[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 Uncommon->getAsDeducedTemplateName();
return nullptr;
}
[AST] Refactor propagation of dependency bits. NFC Summary: This changes introduces an enum to represent dependencies as a bitmask and extract common patterns from code that computes dependency bits into helper functions. Reviewers: rsmith, martong, shafik, ilya-biryukov, hokein Subscribers: hokein, sammccall, Mordante, riccibruno, merge_guards_bot, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71920
2020-03-02 16:07:09 +01:00
TemplateNameDependence TemplateName::getDependence() const {
switch (getKind()) {
[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
case NameKind::Template:
case NameKind::UsingTemplate: {
TemplateDecl *Template = getAsTemplateDecl();
auto D = TemplateNameDependence::None;
[AST] Refactor propagation of dependency bits. NFC Summary: This changes introduces an enum to represent dependencies as a bitmask and extract common patterns from code that computes dependency bits into helper functions. Reviewers: rsmith, martong, shafik, ilya-biryukov, hokein Subscribers: hokein, sammccall, Mordante, riccibruno, merge_guards_bot, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71920
2020-03-02 16:07:09 +01:00
if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template)) {
D |= TemplateNameDependence::DependentInstantiation;
if (TTP->isParameterPack())
D |= TemplateNameDependence::UnexpandedPack;
}
Fix C++ PCH issues. PCH got a severe beating by the boost-using test case reported here: http://llvm.org/PR8099 Fix issues like: -When PCH reading, make sure Decl's getASTContext() doesn't get called since a Decl in the parent hierarchy may be initializing. -In ASTDeclReader::VisitFunctionDecl VisitRedeclarable should be called before using FunctionDecl's isCanonicalDecl() -In ASTDeclReader::VisitRedeclarableTemplateDecl CommonOrPrev must be initialized before anything else. llvm-svn: 113391
2010-09-08 19:31:22 +00:00
// FIXME: Hack, getDeclContext() can be null if Template is still
// initializing due to PCH reading, so we check it before using it.
// Should probably modify TemplateSpecializationType to allow constructing
// it without the isDependent() checking.
[AST] Refactor propagation of dependency bits. NFC Summary: This changes introduces an enum to represent dependencies as a bitmask and extract common patterns from code that computes dependency bits into helper functions. Reviewers: rsmith, martong, shafik, ilya-biryukov, hokein Subscribers: hokein, sammccall, Mordante, riccibruno, merge_guards_bot, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71920
2020-03-02 16:07:09 +01:00
if (Template->getDeclContext() &&
Template->getDeclContext()->isDependentContext())
D |= TemplateNameDependence::DependentInstantiation;
[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 D;
}
case NameKind::QualifiedTemplate: {
QualifiedTemplateName *S = getAsQualifiedTemplateName();
TemplateNameDependence D = S->getUnderlyingTemplate().getDependence();
if (NestedNameSpecifier *NNS = S->getQualifier())
D |= toTemplateNameDependence(NNS->getDependence());
return D;
}
case NameKind::DependentTemplate: {
DependentTemplateName *S = getAsDependentTemplateName();
auto D = TemplateNameDependence::DependentInstantiation;
[clang] improved preservation of template keyword (#133610)
2025-04-01 17:15:18 -03:00
if (NestedNameSpecifier *Qualifier = S->getQualifier())
D |= toTemplateNameDependence(Qualifier->getDependence());
[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 D;
}
case NameKind::SubstTemplateTemplateParm: {
auto *S = getAsSubstTemplateTemplateParm();
return S->getReplacement().getDependence();
}
case NameKind::SubstTemplateTemplateParmPack:
return TemplateNameDependence::UnexpandedPack |
TemplateNameDependence::DependentInstantiation;
case NameKind::DeducedTemplate: {
DeducedTemplateStorage *DTS = getAsDeducedTemplateName();
TemplateNameDependence D = DTS->getUnderlying().getDependence();
for (const TemplateArgument &Arg : DTS->getDefaultArguments().Args)
D |= toTemplateNameDependence(Arg.getDependence());
return D;
}
case NameKind::AssumedTemplate:
return TemplateNameDependence::DependentInstantiation;
case NameKind::OverloadedTemplate:
llvm_unreachable("overloaded templates shouldn't survive to here.");
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +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
llvm_unreachable("Unknown TemplateName kind");
[AST] Refactor propagation of dependency bits. NFC Summary: This changes introduces an enum to represent dependencies as a bitmask and extract common patterns from code that computes dependency bits into helper functions. Reviewers: rsmith, martong, shafik, ilya-biryukov, hokein Subscribers: hokein, sammccall, Mordante, riccibruno, merge_guards_bot, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71920
2020-03-02 16:07:09 +01:00
}
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
[AST] Refactor propagation of dependency bits. NFC Summary: This changes introduces an enum to represent dependencies as a bitmask and extract common patterns from code that computes dependency bits into helper functions. Reviewers: rsmith, martong, shafik, ilya-biryukov, hokein Subscribers: hokein, sammccall, Mordante, riccibruno, merge_guards_bot, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71920
2020-03-02 16:07:09 +01:00
bool TemplateName::isDependent() const {
return getDependence() & TemplateNameDependence::Dependent;
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
}
Introduce the notion of instantiation dependence into Clang's AST. A type/expression/template argument/etc. is instantiation-dependent if it somehow involves a template parameter, even if it doesn't meet the requirements for the more common kinds of dependence (dependent type, type-dependent expression, value-dependent expression). When we see an instantiation-dependent type, we know we always need to perform substitution into that instantiation-dependent type. This keeps us from short-circuiting evaluation in places where we shouldn't, and lets us properly implement C++0x [temp.type]p2. In theory, this would also allow us to properly mangle instantiation-dependent-but-not-dependent decltype types per the Itanium C++ ABI, but we aren't quite there because we still mangle based on the canonical type in cases like, e.g., template<unsigned> struct A { }; template<typename T> void f(A<sizeof(sizeof(decltype(T() + T())))>) { } template void f<int>(A<sizeof(sizeof(int))>); and therefore get the wrong answer. llvm-svn: 134225
2011-07-01 01:22:09 +00:00
bool TemplateName::isInstantiationDependent() const {
[AST] Refactor propagation of dependency bits. NFC Summary: This changes introduces an enum to represent dependencies as a bitmask and extract common patterns from code that computes dependency bits into helper functions. Reviewers: rsmith, martong, shafik, ilya-biryukov, hokein Subscribers: hokein, sammccall, Mordante, riccibruno, merge_guards_bot, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71920
2020-03-02 16:07:09 +01:00
return getDependence() & TemplateNameDependence::Instantiation;
Introduce the notion of instantiation dependence into Clang's AST. A type/expression/template argument/etc. is instantiation-dependent if it somehow involves a template parameter, even if it doesn't meet the requirements for the more common kinds of dependence (dependent type, type-dependent expression, value-dependent expression). When we see an instantiation-dependent type, we know we always need to perform substitution into that instantiation-dependent type. This keeps us from short-circuiting evaluation in places where we shouldn't, and lets us properly implement C++0x [temp.type]p2. In theory, this would also allow us to properly mangle instantiation-dependent-but-not-dependent decltype types per the Itanium C++ ABI, but we aren't quite there because we still mangle based on the canonical type in cases like, e.g., template<unsigned> struct A { }; template<typename T> void f(A<sizeof(sizeof(decltype(T() + T())))>) { } template void f<int>(A<sizeof(sizeof(int))>); and therefore get the wrong answer. llvm-svn: 134225
2011-07-01 01:22:09 +00:00
}
Variadic templates: extend Type, NestedNameSpecifier, TemplateName, and TemplateArgument with an operation that determines whether there are any unexpanded parameter packs within that construct. Use this information to diagnose the appearance of the names of parameter packs that have not been expanded (C++ [temp.variadic]p5). Since this property is checked often (every declaration, ever expression statement, etc.), we extend Type and Expr with a bit storing the result of this computation, rather than walking the AST each time to determine whether any unexpanded parameter packs occur. This commit is deficient in several ways, which will be remedied with future commits: - Expr has a bit to store the presence of an unexpanded parameter pack, but it is never set. - The error messages don't point out where the unexpanded parameter packs were named in the type/expression, but they should. - We don't check for unexpanded parameter packs in all of the places where we should. - Testing is sparse, pending the resolution of the above three issues. llvm-svn: 121724
2010-12-13 22:49:22 +00:00
bool TemplateName::containsUnexpandedParameterPack() const {
[AST] Refactor propagation of dependency bits. NFC Summary: This changes introduces an enum to represent dependencies as a bitmask and extract common patterns from code that computes dependency bits into helper functions. Reviewers: rsmith, martong, shafik, ilya-biryukov, hokein Subscribers: hokein, sammccall, Mordante, riccibruno, merge_guards_bot, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71920
2020-03-02 16:07:09 +01:00
return getDependence() & TemplateNameDependence::UnexpandedPack;
Variadic templates: extend Type, NestedNameSpecifier, TemplateName, and TemplateArgument with an operation that determines whether there are any unexpanded parameter packs within that construct. Use this information to diagnose the appearance of the names of parameter packs that have not been expanded (C++ [temp.variadic]p5). Since this property is checked often (every declaration, ever expression statement, etc.), we extend Type and Expr with a bit storing the result of this computation, rather than walking the AST each time to determine whether any unexpanded parameter packs occur. This commit is deficient in several ways, which will be remedied with future commits: - Expr has a bit to store the presence of an unexpanded parameter pack, but it is never set. - The error messages don't point out where the unexpanded parameter packs were named in the type/expression, but they should. - We don't check for unexpanded parameter packs in all of the places where we should. - Testing is sparse, pending the resolution of the above three issues. llvm-svn: 121724
2010-12-13 22:49:22 +00:00
}
Fully qualify template template parameters when printing I discovered this quirk when working on some DWARF - AST printing prints type template parameters fully qualified, but printed template template parameters the way they were written syntactically, or wholely unqualified - instead, we should print them consistently with the way we print type template parameters: fully qualified. The one place this got weird was for partial specializations like in ast-print-temp-class.cpp - hence the need for checking for TemplateNameDependenceScope::DependentInstantiation template template parameters. (not 100% sure that's the right solution to that, though - open to ideas) Differential Revision: https://reviews.llvm.org/D108794
2021-08-26 16:54:47 -07:00
void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
Qualified Qual) const {
[clang] implement printing of canonical expressions (#135133) This patch extends the canonicalization printing policy to cover expressions and template names, and wires that up to the template argument printer, covering expressions, and to the expression within a dependent decltype. This is helpful for debugging, or if these expressions somehow end up in diagnostics, as without this patch they can print as completely unrelated expressions, which can be quite confusing. This is because expressions are not uniqued, unlike types, and when a template specialization containing an expression is the first to be canonicalized, the expression ends up appearing in the canonical type of subsequent equivalent specializations. Fixes https://github.com/llvm/llvm-project/issues/92292
2025-04-14 12:59:36 -03:00
auto handleAnonymousTTP = [&](TemplateDecl *TD, raw_ostream &OS) {
[clang] fix printing of canonical template template parameters take 2 (#93448) Since they can also occur as the template name of template specializations, handle them from TemplateName printing instead of TemplateArgument.
2024-05-29 21:45:01 -03:00
if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(TD);
[clang] implement printing of canonical expressions (#135133) This patch extends the canonicalization printing policy to cover expressions and template names, and wires that up to the template argument printer, covering expressions, and to the expression within a dependent decltype. This is helpful for debugging, or if these expressions somehow end up in diagnostics, as without this patch they can print as completely unrelated expressions, which can be quite confusing. This is because expressions are not uniqued, unlike types, and when a template specialization containing an expression is the first to be canonicalized, the expression ends up appearing in the canonical type of subsequent equivalent specializations. Fixes https://github.com/llvm/llvm-project/issues/92292
2025-04-14 12:59:36 -03:00
TTP && (Policy.PrintAsCanonical || TTP->getIdentifier() == nullptr)) {
[clang] fix printing of canonical template template parameters take 2 (#93448) Since they can also occur as the template name of template specializations, handle them from TemplateName printing instead of TemplateArgument.
2024-05-29 21:45:01 -03:00
OS << "template-parameter-" << TTP->getDepth() << "-" << TTP->getIndex();
return true;
}
return false;
};
[clang] Preserve Qualifiers and type sugar in TemplateNames (#93433) This patch improves the preservation of qualifiers and loss of type sugar in TemplateNames. This problem is analogous to https://reviews.llvm.org/D112374 and this patch takes a very similar approach to that patch, except the impact here is much lesser. When a TemplateName was written bare, without qualifications, we wouldn't produce a QualifiedTemplate which could be used to disambiguate it from a Canonical TemplateName. This had effects in the TemplateName printer, which had workarounds to deal with this, and wouldn't print the TemplateName as-written in most situations. There are also some related fixes to help preserve this type sugar along the way into diagnostics, so that this patch can be properly tested. - Fix dropping the template keyword. - Fix type deduction to preserve sugar in TST TemplateNames.
2024-05-29 17:02:15 -03:00
if (NameKind Kind = getKind();
Kind == TemplateName::Template || Kind == TemplateName::UsingTemplate) {
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02:00
// After `namespace ns { using std::vector }`, what is the fully-qualified
// name of the UsingTemplateName `vector` within ns?
//
// - ns::vector (the qualified name of the using-shadow decl)
// - std::vector (the qualified name of the underlying template decl)
//
// Similar to the UsingType behavior, using declarations are used to import
// names more often than to export them, thus using the original name is
// most useful in this case.
[clang] Preserve Qualifiers and type sugar in TemplateNames (#93433) This patch improves the preservation of qualifiers and loss of type sugar in TemplateNames. This problem is analogous to https://reviews.llvm.org/D112374 and this patch takes a very similar approach to that patch, except the impact here is much lesser. When a TemplateName was written bare, without qualifications, we wouldn't produce a QualifiedTemplate which could be used to disambiguate it from a Canonical TemplateName. This had effects in the TemplateName printer, which had workarounds to deal with this, and wouldn't print the TemplateName as-written in most situations. There are also some related fixes to help preserve this type sugar along the way into diagnostics, so that this patch can be properly tested. - Fix dropping the template keyword. - Fix type deduction to preserve sugar in TST TemplateNames.
2024-05-29 17:02:15 -03:00
TemplateDecl *Template = getAsTemplateDecl();
[clang] implement printing of canonical expressions (#135133) This patch extends the canonicalization printing policy to cover expressions and template names, and wires that up to the template argument printer, covering expressions, and to the expression within a dependent decltype. This is helpful for debugging, or if these expressions somehow end up in diagnostics, as without this patch they can print as completely unrelated expressions, which can be quite confusing. This is because expressions are not uniqued, unlike types, and when a template specialization containing an expression is the first to be canonicalized, the expression ends up appearing in the canonical type of subsequent equivalent specializations. Fixes https://github.com/llvm/llvm-project/issues/92292
2025-04-14 12:59:36 -03:00
if (Policy.PrintAsCanonical)
Template = cast<TemplateDecl>(Template->getCanonicalDecl());
[clang] fix printing of canonical template template parameters take 2 (#93448) Since they can also occur as the template name of template specializations, handle them from TemplateName printing instead of TemplateArgument.
2024-05-29 21:45:01 -03:00
if (handleAnonymousTTP(Template, OS))
return;
[clang] Preserve Qualifiers and type sugar in TemplateNames (#93433) This patch improves the preservation of qualifiers and loss of type sugar in TemplateNames. This problem is analogous to https://reviews.llvm.org/D112374 and this patch takes a very similar approach to that patch, except the impact here is much lesser. When a TemplateName was written bare, without qualifications, we wouldn't produce a QualifiedTemplate which could be used to disambiguate it from a Canonical TemplateName. This had effects in the TemplateName printer, which had workarounds to deal with this, and wouldn't print the TemplateName as-written in most situations. There are also some related fixes to help preserve this type sugar along the way into diagnostics, so that this patch can be properly tested. - Fix dropping the template keyword. - Fix type deduction to preserve sugar in TST TemplateNames.
2024-05-29 17:02:15 -03:00
if (Qual == Qualified::None)
Fully qualify template template parameters when printing I discovered this quirk when working on some DWARF - AST printing prints type template parameters fully qualified, but printed template template parameters the way they were written syntactically, or wholely unqualified - instead, we should print them consistently with the way we print type template parameters: fully qualified. The one place this got weird was for partial specializations like in ast-print-temp-class.cpp - hence the need for checking for TemplateNameDependenceScope::DependentInstantiation template template parameters. (not 100% sure that's the right solution to that, though - open to ideas) Differential Revision: https://reviews.llvm.org/D108794
2021-08-26 16:54:47 -07:00
OS << *Template;
[clang] Preserve Qualifiers and type sugar in TemplateNames (#93433) This patch improves the preservation of qualifiers and loss of type sugar in TemplateNames. This problem is analogous to https://reviews.llvm.org/D112374 and this patch takes a very similar approach to that patch, except the impact here is much lesser. When a TemplateName was written bare, without qualifications, we wouldn't produce a QualifiedTemplate which could be used to disambiguate it from a Canonical TemplateName. This had effects in the TemplateName printer, which had workarounds to deal with this, and wouldn't print the TemplateName as-written in most situations. There are also some related fixes to help preserve this type sugar along the way into diagnostics, so that this patch can be properly tested. - Fix dropping the template keyword. - Fix type deduction to preserve sugar in TST TemplateNames.
2024-05-29 17:02:15 -03:00
else
Template->printQualifiedName(OS, Policy);
} else if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName()) {
[clang] implement printing of canonical expressions (#135133) This patch extends the canonicalization printing policy to cover expressions and template names, and wires that up to the template argument printer, covering expressions, and to the expression within a dependent decltype. This is helpful for debugging, or if these expressions somehow end up in diagnostics, as without this patch they can print as completely unrelated expressions, which can be quite confusing. This is because expressions are not uniqued, unlike types, and when a template specialization containing an expression is the first to be canonicalized, the expression ends up appearing in the canonical type of subsequent equivalent specializations. Fixes https://github.com/llvm/llvm-project/issues/92292
2025-04-14 12:59:36 -03:00
if (Policy.PrintAsCanonical) {
QTN->getUnderlyingTemplate().print(OS, Policy, Qual);
return;
}
[clang] Preserve Qualifiers and type sugar in TemplateNames (#93433) This patch improves the preservation of qualifiers and loss of type sugar in TemplateNames. This problem is analogous to https://reviews.llvm.org/D112374 and this patch takes a very similar approach to that patch, except the impact here is much lesser. When a TemplateName was written bare, without qualifications, we wouldn't produce a QualifiedTemplate which could be used to disambiguate it from a Canonical TemplateName. This had effects in the TemplateName printer, which had workarounds to deal with this, and wouldn't print the TemplateName as-written in most situations. There are also some related fixes to help preserve this type sugar along the way into diagnostics, so that this patch can be properly tested. - Fix dropping the template keyword. - Fix type deduction to preserve sugar in TST TemplateNames.
2024-05-29 17:02:15 -03:00
if (NestedNameSpecifier *NNS = QTN->getQualifier();
Qual != Qualified::None && NNS)
NNS->print(OS, Policy);
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
if (QTN->hasTemplateKeyword())
OS << "template ";
[clang] Preserve Qualifiers and type sugar in TemplateNames (#93433) This patch improves the preservation of qualifiers and loss of type sugar in TemplateNames. This problem is analogous to https://reviews.llvm.org/D112374 and this patch takes a very similar approach to that patch, except the impact here is much lesser. When a TemplateName was written bare, without qualifications, we wouldn't produce a QualifiedTemplate which could be used to disambiguate it from a Canonical TemplateName. This had effects in the TemplateName printer, which had workarounds to deal with this, and wouldn't print the TemplateName as-written in most situations. There are also some related fixes to help preserve this type sugar along the way into diagnostics, so that this patch can be properly tested. - Fix dropping the template keyword. - Fix type deduction to preserve sugar in TST TemplateNames.
2024-05-29 17:02:15 -03:00
TemplateName Underlying = QTN->getUnderlyingTemplate();
assert(Underlying.getKind() == TemplateName::Template ||
Underlying.getKind() == TemplateName::UsingTemplate);
TemplateDecl *UTD = Underlying.getAsTemplateDecl();
[clang] fix printing of canonical template template parameters take 2 (#93448) Since they can also occur as the template name of template specializations, handle them from TemplateName printing instead of TemplateArgument.
2024-05-29 21:45:01 -03:00
if (handleAnonymousTTP(UTD, OS))
return;
[clang] Preserve Qualifiers and type sugar in TemplateNames (#93433) This patch improves the preservation of qualifiers and loss of type sugar in TemplateNames. This problem is analogous to https://reviews.llvm.org/D112374 and this patch takes a very similar approach to that patch, except the impact here is much lesser. When a TemplateName was written bare, without qualifications, we wouldn't produce a QualifiedTemplate which could be used to disambiguate it from a Canonical TemplateName. This had effects in the TemplateName printer, which had workarounds to deal with this, and wouldn't print the TemplateName as-written in most situations. There are also some related fixes to help preserve this type sugar along the way into diagnostics, so that this patch can be properly tested. - Fix dropping the template keyword. - Fix type deduction to preserve sugar in TST TemplateNames.
2024-05-29 17:02:15 -03:00
if (IdentifierInfo *II = UTD->getIdentifier();
Policy.CleanUglifiedParameters && II &&
isa<TemplateTemplateParmDecl>(UTD))
OS << II->deuglifiedName();
else
OS << *UTD;
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
} else if (DependentTemplateName *DTN = getAsDependentTemplateName()) {
[clang] improved preservation of template keyword (#133610)
2025-04-01 17:15:18 -03:00
DTN->print(OS, Policy);
[clang] Preserve Qualifiers and type sugar in TemplateNames (#93433) This patch improves the preservation of qualifiers and loss of type sugar in TemplateNames. This problem is analogous to https://reviews.llvm.org/D112374 and this patch takes a very similar approach to that patch, except the impact here is much lesser. When a TemplateName was written bare, without qualifications, we wouldn't produce a QualifiedTemplate which could be used to disambiguate it from a Canonical TemplateName. This had effects in the TemplateName printer, which had workarounds to deal with this, and wouldn't print the TemplateName as-written in most situations. There are also some related fixes to help preserve this type sugar along the way into diagnostics, so that this patch can be properly tested. - Fix dropping the template keyword. - Fix type deduction to preserve sugar in TST TemplateNames.
2024-05-29 17:02:15 -03:00
} else if (SubstTemplateTemplateParmStorage *subst =
getAsSubstTemplateTemplateParm()) {
Fully qualify template template parameters when printing I discovered this quirk when working on some DWARF - AST printing prints type template parameters fully qualified, but printed template template parameters the way they were written syntactically, or wholely unqualified - instead, we should print them consistently with the way we print type template parameters: fully qualified. The one place this got weird was for partial specializations like in ast-print-temp-class.cpp - hence the need for checking for TemplateNameDependenceScope::DependentInstantiation template template parameters. (not 100% sure that's the right solution to that, though - open to ideas) Differential Revision: https://reviews.llvm.org/D108794
2021-08-26 16:54:47 -07:00
subst->getReplacement().print(OS, Policy, Qual);
[clang] Preserve Qualifiers and type sugar in TemplateNames (#93433) This patch improves the preservation of qualifiers and loss of type sugar in TemplateNames. This problem is analogous to https://reviews.llvm.org/D112374 and this patch takes a very similar approach to that patch, except the impact here is much lesser. When a TemplateName was written bare, without qualifications, we wouldn't produce a QualifiedTemplate which could be used to disambiguate it from a Canonical TemplateName. This had effects in the TemplateName printer, which had workarounds to deal with this, and wouldn't print the TemplateName as-written in most situations. There are also some related fixes to help preserve this type sugar along the way into diagnostics, so that this patch can be properly tested. - Fix dropping the template keyword. - Fix type deduction to preserve sugar in TST TemplateNames.
2024-05-29 17:02:15 -03:00
} else if (SubstTemplateTemplateParmPackStorage *SubstPack =
getAsSubstTemplateTemplateParmPack())
Print NamedDecls directly to a raw_ostream where possible. llvm-svn: 149982
2012-02-07 11:57:57 +00:00
OS << *SubstPack->getParameterPack();
[c++20] Implement P0846R0: allow (ADL-only) calls to template-ids whose template name is not visible to unqualified lookup. In order to support this without a severe degradation in our ability to diagnose typos in template names, this change significantly restructures the way we handle template-id-shaped syntax for which lookup of the template name finds nothing. Instead of eagerly diagnosing an undeclared template name, we now form a placeholder template-name representing a name that is known to not find any templates. When the parser sees such a name, it attempts to disambiguate whether we have a less-than comparison or a template-id. Any diagnostics or typo-correction for the name are delayed until its point of use. The upshot should be a small improvement of our diagostic quality overall: we now take more syntactic context into account when trying to resolve an undeclared identifier on the left hand side of a '<'. In fact, this works well enough that the backwards-compatible portion (for an undeclared identifier rather than a lookup that finds functions but no function templates) is enabled in all language modes. llvm-svn: 360308
2019-05-09 03:31:27 +00:00
else if (AssumedTemplateStorage *Assumed = getAsAssumedTemplateName()) {
Assumed->getDeclName().print(OS, Policy);
[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
} else if (DeducedTemplateStorage *Deduced = getAsDeducedTemplateName()) {
Deduced->getUnderlying().print(OS, Policy);
DefaultArguments DefArgs = Deduced->getDefaultArguments();
OS << ":" << DefArgs.StartPos;
printTemplateArgumentList(OS, DefArgs.Args, Policy);
[c++20] Implement P0846R0: allow (ADL-only) calls to template-ids whose template name is not visible to unqualified lookup. In order to support this without a severe degradation in our ability to diagnose typos in template names, this change significantly restructures the way we handle template-id-shaped syntax for which lookup of the template name finds nothing. Instead of eagerly diagnosing an undeclared template name, we now form a placeholder template-name representing a name that is known to not find any templates. When the parser sees such a name, it attempts to disambiguate whether we have a less-than comparison or a template-id. Any diagnostics or typo-correction for the name are delayed until its point of use. The upshot should be a small improvement of our diagostic quality overall: we now take more syntactic context into account when trying to resolve an undeclared identifier on the left hand side of a '<'. In fact, this works well enough that the backwards-compatible portion (for an undeclared identifier rather than a lookup that finds functions but no function templates) is enabled in all language modes. llvm-svn: 360308
2019-05-09 03:31:27 +00:00
} else {
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02:00
assert(getKind() == TemplateName::OverloadedTemplate);
Teach Sema::ActOnCXXNestedNameSpecifier and Sema::CheckTemplateIdType to cope with non-type templates by providing appropriate errors. Previously, we would either assert, crash, or silently build a dependent type when we shouldn't. Fixes PR9226. llvm-svn: 127037
2011-03-04 21:37:14 +00:00
OverloadedTemplateStorage *OTS = getAsOverloadedTemplate();
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
(*OTS->begin())->printName(OS, Policy);
Teach Sema::ActOnCXXNestedNameSpecifier and Sema::CheckTemplateIdType to cope with non-type templates by providing appropriate errors. Previously, we would either assert, crash, or silently build a dependent type when we shouldn't. Fixes PR9226. llvm-svn: 127037
2011-03-04 21:37:14 +00:00
}
Improve the representation of template names in the AST. This representation handles the various ways in which one can name a template, including unqualified references ("vector"), qualified references ("std::vector"), and dependent template names ("MetaFun::template apply"). One immediate effect of this change is that the representation of nested-name-specifiers in type names for class template specializations (e.g., std::vector<int>) is more accurate. Rather than representing std::vector<int> as std::(vector<int>) we represent it as (std::vector)<int> which more closely follows the C++ grammar. Additionally, templates are no longer represented as declarations (DeclPtrTy) in Parse-Sema interactions. Instead, I've introduced a new OpaquePtr type (TemplateTy) that holds the representation of a TemplateName. This will simplify the handling of dependent template-names, once we get there. llvm-svn: 68074
2009-03-30 22:58:21 +00:00
}
Implement template instantiation for template names, including both template template parameters and dependent template names. For example, the oft-mentioned typename MetaFun::template apply<T1, T2>::type can now be instantiated, with the appropriate name lookup for "apply". llvm-svn: 68128
2009-03-31 18:38:02 +00:00
[NFC] Refactor DiagnosticBuilder and PartialDiagnostic PartialDiagnostic misses some functions compared to DiagnosticBuilder. This patch refactors DiagnosticBuilder and PartialDiagnostic, extracts the common functionality so that the streaming << operators are shared. Differential Revision: https://reviews.llvm.org/D84362
2020-09-23 16:16:00 -04:00
const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
TemplateName N) {
When a template (without arguments) is passed as a template type parameter, explicitly ask the user to give it arguments. We used to complain that it wasn't a type and expect the user to figure it out. llvm-svn: 100729
2010-04-08 00:03:06 +00:00
std::string NameStr;
[AST] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 318813
2017-11-21 23:26:08 +00:00
llvm::raw_string_ostream OS(NameStr);
When a template (without arguments) is passed as a template type parameter, explicitly ask the user to give it arguments. We used to complain that it wasn't a type and expect the user to figure it out. llvm-svn: 100729
2010-04-08 00:03:06 +00:00
LangOptions LO;
LO.CPlusPlus = true;
LO.Bool = true;
Add quotation marks to template names in diagnostics. llvm-svn: 176474
2013-03-05 06:21:38 +00:00
OS << '\'';
When a template (without arguments) is passed as a template type parameter, explicitly ask the user to give it arguments. We used to complain that it wasn't a type and expect the user to figure it out. llvm-svn: 100729
2010-04-08 00:03:06 +00:00
N.print(OS, PrintingPolicy(LO));
Add quotation marks to template names in diagnostics. llvm-svn: 176474
2013-03-05 06:21:38 +00:00
OS << '\'';
When a template (without arguments) is passed as a template type parameter, explicitly ask the user to give it arguments. We used to complain that it wasn't a type and expect the user to figure it out. llvm-svn: 100729
2010-04-08 00:03:06 +00:00
return DB << NameStr;
}
Reference in New Issue Copy Permalink