This is an archive of the discontinued LLVM Phabricator instance.

Differential D78567

C++2a -> C++20 in some identifiers; NFC
ClosedPublic

Authored by aaron.ballman on Apr 21 2020, 7:46 AM.

Details

Reviewers
rsmith
dblaikie
echristo
Summary

This does not hit all of the C++2a -> C++20 changes, but gets all of the ones related to the language options and keywords.

Diff Detail

Event Timeline

aaron.ballman created this revision.Apr 21 2020, 7:46 AM
Herald added subscribers: martong, kbarton, nemanjai. · View Herald TranscriptApr 21 2020, 7:46 AM
dblaikie accepted this revision.Apr 21 2020, 12:09 PM

Sounds good!

This revision is now accepted and ready to land.Apr 21 2020, 12:09 PM
Herald added a subscriber: • wuzish. · View Herald TranscriptApr 21 2020, 12:09 PM
aaron.ballman closed this revision.Apr 21 2020, 12:38 PM

Thanks! I've committed in 6a30894391ca671bab16c505eff30c7819bd8e8e. If I get a spare moment, I may do this dance again with diagnostic identifers as well.

Revision Contents

PathSize
clang-tools-extra/
clang-tidy/
cppcoreguidelines/
2 lines
modernize/
2 lines
portability/
2 lines
clang/
include/
clang/
AST/
6 lines
Basic/
4 lines
6 lines
4 lines
22 lines
lib/
AST/
6 lines
2 lines
20 lines
Interp/
2 lines
2 lines
Basic/
10 lines
Targets/
2 lines
CodeGen/
2 lines
CrossTU/
2 lines
Format/
2 lines
Frontend/
8 lines
10 lines
Lex/
2 lines
2 lines
4 lines
4 lines
Parse/
6 lines
6 lines
2 lines
2 lines
2 lines
Sema/
12 lines
2 lines
46 lines
30 lines
2 lines
2 lines
6 lines
2 lines
6 lines
18 lines
StaticAnalyzer/
Core/
2 lines

Diff 259000

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

Show First 20 Lines • Show All 450 Lines • ▼ Show 20 Linesvoid ProTypeMemberInitCheck::checkMissingMemberInitializer(
SmallPtrSet<const RecordDecl *, 4> UnionsSeen; SmallPtrSet<const RecordDecl *, 4> UnionsSeen;
forEachField(ClassDecl, OrderedFields, [&](const FieldDecl *F) { forEachField(ClassDecl, OrderedFields, [&](const FieldDecl *F) {
if (!FieldsToInit.count(F)) if (!FieldsToInit.count(F))
return; return;
// Don't suggest fixes for enums because we don't know a good default. // Don't suggest fixes for enums because we don't know a good default.
// Don't suggest fixes for bitfields because in-class initialization is not // Don't suggest fixes for bitfields because in-class initialization is not
// possible until C++2a. // possible until C++2a.
if (F->getType()->isEnumeralType() || if (F->getType()->isEnumeralType() ||
(!getLangOpts().CPlusPlus2a && F->isBitField())) (!getLangOpts().CPlusPlus20 && F->isBitField()))
return; return;
if (!F->getParent()->isUnion() || UnionsSeen.insert(F->getParent()).second) if (!F->getParent()->isUnion() || UnionsSeen.insert(F->getParent()).second)
FieldsToFix.insert(F); FieldsToFix.insert(F);
}); });
if (FieldsToFix.empty()) if (FieldsToFix.empty())
return; return;
// Use in-class initialization if possible. // Use in-class initialization if possible.
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

Show First 20 Lines • Show All 211 Lines • ▼ Show 20 Lines auto Init =
initCountIs(0))), initCountIs(0))),
InitBase); InitBase);
Finder->addMatcher( Finder->addMatcher(
cxxConstructorDecl( cxxConstructorDecl(
isDefaultConstructor(), unless(isInstantiated()), isDefaultConstructor(), unless(isInstantiated()),
forEachConstructorInitializer( forEachConstructorInitializer(
cxxCtorInitializer( cxxCtorInitializer(
forField(unless(anyOf(getLangOpts().CPlusPlus2a forField(unless(anyOf(getLangOpts().CPlusPlus20
? unless(anything()) ? unless(anything())
: isBitField(), : isBitField(),
hasInClassInitializer(anything()), hasInClassInitializer(anything()),
hasParent(recordDecl(isUnion()))))), hasParent(recordDecl(isUnion()))))),
isWritten(), withInitializer(ignoringImplicit(Init))) isWritten(), withInitializer(ignoringImplicit(Init)))
.bind("default"))), .bind("default"))),
this); this);
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/portability/SIMDIntrinsicsCheck.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linesvoid SIMDIntrinsicsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "Std", ""); Options.store(Opts, "Std", "");
Options.store(Opts, "Suggest", 0); Options.store(Opts, "Suggest", 0);
} }
void SIMDIntrinsicsCheck::registerMatchers(MatchFinder *Finder) { void SIMDIntrinsicsCheck::registerMatchers(MatchFinder *Finder) {
// If Std is not specified, infer it from the language options. // If Std is not specified, infer it from the language options.
// libcxx implementation backports it to C++11 std::experimental::simd. // libcxx implementation backports it to C++11 std::experimental::simd.
if (Std.empty()) if (Std.empty())
Std = getLangOpts().CPlusPlus2a ? "std" : "std::experimental"; Std = getLangOpts().CPlusPlus20 ? "std" : "std::experimental";
Finder->addMatcher(callExpr(callee(functionDecl( Finder->addMatcher(callExpr(callee(functionDecl(
matchesName("^::(_mm_|_mm256_|_mm512_|vec_)"), matchesName("^::(_mm_|_mm256_|_mm512_|vec_)"),
isVectorFunction())), isVectorFunction())),
unless(isExpansionInSystemHeader())) unless(isExpansionInSystemHeader()))
.bind("call"), .bind("call"),
this); this);
} }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

clang/include/clang/AST/DeclCXX.h

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
defaultedDefaultConstructorIsConstexpr()); defaultedDefaultConstructorIsConstexpr());
} }
/// Determine whether a defaulted default constructor for this class /// Determine whether a defaulted default constructor for this class
/// would be constexpr. /// would be constexpr.
bool defaultedDefaultConstructorIsConstexpr() const { bool defaultedDefaultConstructorIsConstexpr() const {
return data().DefaultedDefaultConstructorIsConstexpr && return data().DefaultedDefaultConstructorIsConstexpr &&
(!isUnion() || hasInClassInitializer() || !hasVariantMembers() || (!isUnion() || hasInClassInitializer() || !hasVariantMembers() ||
getLangOpts().CPlusPlus2a); getLangOpts().CPlusPlus20);
} }
/// Determine whether this class has a constexpr default constructor. /// Determine whether this class has a constexpr default constructor.
bool hasConstexprDefaultConstructor() const { bool hasConstexprDefaultConstructor() const {
return data().HasConstexprDefaultConstructor || return data().HasConstexprDefaultConstructor ||
(needsImplicitDefaultConstructor() && (needsImplicitDefaultConstructor() &&
defaultedDefaultConstructorIsConstexpr()); defaultedDefaultConstructorIsConstexpr());
} }
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
(needsImplicitMoveAssignment() && (needsImplicitMoveAssignment() &&
!(data().HasTrivialSpecialMembers & SMF_MoveAssignment)); !(data().HasTrivialSpecialMembers & SMF_MoveAssignment));
} }
/// Determine whether a defaulted default constructor for this class /// Determine whether a defaulted default constructor for this class
/// would be constexpr. /// would be constexpr.
bool defaultedDestructorIsConstexpr() const { bool defaultedDestructorIsConstexpr() const {
return data().DefaultedDestructorIsConstexpr && return data().DefaultedDestructorIsConstexpr &&
getLangOpts().CPlusPlus2a; getLangOpts().CPlusPlus20;
} }
/// Determine whether this class has a constexpr destructor. /// Determine whether this class has a constexpr destructor.
bool hasConstexprDestructor() const; bool hasConstexprDestructor() const;
/// Determine whether this class has a trivial destructor /// Determine whether this class has a trivial destructor
/// (C++ [class.dtor]p3) /// (C++ [class.dtor]p3)
bool hasTrivialDestructor() const { bool hasTrivialDestructor() const {
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
/// types /// types
/// ///
/// We resolve DR1361 by ignoring the second bullet. We resolve DR1452 by /// We resolve DR1361 by ignoring the second bullet. We resolve DR1452 by
/// treating types with trivial default constructors as literal types. /// treating types with trivial default constructors as literal types.
/// ///
/// Only in C++17 and beyond, are lambdas literal types. /// Only in C++17 and beyond, are lambdas literal types.
bool isLiteral() const { bool isLiteral() const {
const LangOptions &LangOpts = getLangOpts(); const LangOptions &LangOpts = getLangOpts();
return (LangOpts.CPlusPlus2a ? hasConstexprDestructor() return (LangOpts.CPlusPlus20 ? hasConstexprDestructor()
: hasTrivialDestructor()) && : hasTrivialDestructor()) &&
(!isLambda() || LangOpts.CPlusPlus17) && (!isLambda() || LangOpts.CPlusPlus17) &&
!hasNonLiteralTypeFieldsOrBases() && !hasNonLiteralTypeFieldsOrBases() &&
(isAggregate() || isLambda() || (isAggregate() || isLambda() ||
hasConstexprNonCopyMoveConstructor() || hasConstexprNonCopyMoveConstructor() ||
hasTrivialDefaultConstructor()); hasTrivialDefaultConstructor());
} }
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/include/clang/Basic/LangOptions.def

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
LANGOPT(MSVCCompat , 1, 0, "Microsoft Visual C++ full compatibility mode") LANGOPT(MSVCCompat , 1, 0, "Microsoft Visual C++ full compatibility mode")
LANGOPT(MicrosoftExt , 1, 0, "Microsoft C++ extensions") LANGOPT(MicrosoftExt , 1, 0, "Microsoft C++ extensions")
LANGOPT(AsmBlocks , 1, 0, "Microsoft inline asm blocks") LANGOPT(AsmBlocks , 1, 0, "Microsoft inline asm blocks")
LANGOPT(Borland , 1, 0, "Borland extensions") LANGOPT(Borland , 1, 0, "Borland extensions")
LANGOPT(CPlusPlus , 1, 0, "C++") LANGOPT(CPlusPlus , 1, 0, "C++")
LANGOPT(CPlusPlus11 , 1, 0, "C++11") LANGOPT(CPlusPlus11 , 1, 0, "C++11")
LANGOPT(CPlusPlus14 , 1, 0, "C++14") LANGOPT(CPlusPlus14 , 1, 0, "C++14")
LANGOPT(CPlusPlus17 , 1, 0, "C++17") LANGOPT(CPlusPlus17 , 1, 0, "C++17")
LANGOPT(CPlusPlus2a , 1, 0, "C++2a") LANGOPT(CPlusPlus20 , 1, 0, "C++20")
LANGOPT(ObjC , 1, 0, "Objective-C") LANGOPT(ObjC , 1, 0, "Objective-C")
BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0, BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0,
"Objective-C auto-synthesized properties") "Objective-C auto-synthesized properties")
BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0, BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0,
"Encoding extended block type signature") "Encoding extended block type signature")
BENIGN_LANGOPT(ObjCInferRelatedResultType , 1, 1, BENIGN_LANGOPT(ObjCInferRelatedResultType , 1, 1,
"Objective-C related result type inference") "Objective-C related result type inference")
LANGOPT(AppExt , 1, 0, "Objective-C App Extension") LANGOPT(AppExt , 1, 0, "Objective-C App Extension")
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines
LANGOPT(SYCLVersion , 32, 0, "Version of the SYCL standard used") LANGOPT(SYCLVersion , 32, 0, "Version of the SYCL standard used")
LANGOPT(HIPUseNewLaunchAPI, 1, 0, "Use new kernel launching API for HIP") LANGOPT(HIPUseNewLaunchAPI, 1, 0, "Use new kernel launching API for HIP")
LANGOPT(SizedDeallocation , 1, 0, "sized deallocation") LANGOPT(SizedDeallocation , 1, 0, "sized deallocation")
LANGOPT(AlignedAllocation , 1, 0, "aligned allocation") LANGOPT(AlignedAllocation , 1, 0, "aligned allocation")
LANGOPT(AlignedAllocationUnavailable, 1, 0, "aligned allocation functions are unavailable") LANGOPT(AlignedAllocationUnavailable, 1, 0, "aligned allocation functions are unavailable")
LANGOPT(NewAlignOverride , 32, 0, "maximum alignment guaranteed by '::operator new(size_t)'") LANGOPT(NewAlignOverride , 32, 0, "maximum alignment guaranteed by '::operator new(size_t)'")
LANGOPT(ConceptSatisfactionCaching , 1, 1, "enable satisfaction caching for C++2a Concepts") LANGOPT(ConceptSatisfactionCaching , 1, 1, "enable satisfaction caching for C++20 Concepts")
BENIGN_LANGOPT(ModulesCodegen , 1, 0, "Modules code generation") BENIGN_LANGOPT(ModulesCodegen , 1, 0, "Modules code generation")
BENIGN_LANGOPT(ModulesDebugInfo , 1, 0, "Modules debug info") BENIGN_LANGOPT(ModulesDebugInfo , 1, 0, "Modules debug info")
BENIGN_LANGOPT(ElideConstructors , 1, 1, "C++ copy constructor elision") BENIGN_LANGOPT(ElideConstructors , 1, 1, "C++ copy constructor elision")
BENIGN_LANGOPT(DumpRecordLayouts , 1, 0, "dumping the layout of IRgen'd records") BENIGN_LANGOPT(DumpRecordLayouts , 1, 0, "dumping the layout of IRgen'd records")
BENIGN_LANGOPT(DumpRecordLayoutsSimple , 1, 0, "dumping the layout of IRgen'd records in a simple form") BENIGN_LANGOPT(DumpRecordLayoutsSimple , 1, 0, "dumping the layout of IRgen'd records in a simple form")
BENIGN_LANGOPT(DumpVTableLayouts , 1, 0, "dumping the layouts of emitted vtables") BENIGN_LANGOPT(DumpVTableLayouts , 1, 0, "dumping the layouts of emitted vtables")
LANGOPT(NoConstantCFStrings , 1, 0, "no constant CoreFoundation strings") LANGOPT(NoConstantCFStrings , 1, 0, "no constant CoreFoundation strings")
BENIGN_LANGOPT(InlineVisibilityHidden , 1, 0, "hidden visibility for inline C++ methods") BENIGN_LANGOPT(InlineVisibilityHidden , 1, 0, "hidden visibility for inline C++ methods")
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

clang/include/clang/Basic/LangStandard.h

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesenum LangFeatures {
C99 = (1 << 1), C99 = (1 << 1),
C11 = (1 << 2), C11 = (1 << 2),
C17 = (1 << 3), C17 = (1 << 3),
C2x = (1 << 4), C2x = (1 << 4),
CPlusPlus = (1 << 5), CPlusPlus = (1 << 5),
CPlusPlus11 = (1 << 6), CPlusPlus11 = (1 << 6),
CPlusPlus14 = (1 << 7), CPlusPlus14 = (1 << 7),
CPlusPlus17 = (1 << 8), CPlusPlus17 = (1 << 8),
CPlusPlus2a = (1 << 9), CPlusPlus20 = (1 << 9),
Digraphs = (1 << 10), Digraphs = (1 << 10),
GNUMode = (1 << 11), GNUMode = (1 << 11),
HexFloat = (1 << 12), HexFloat = (1 << 12),
ImplicitInt = (1 << 13), ImplicitInt = (1 << 13),
OpenCL = (1 << 14) OpenCL = (1 << 14)
}; };
/// LangStandard - Information about the properties of a particular language /// LangStandard - Information about the properties of a particular language
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linespublic:
bool isCPlusPlus11() const { return Flags & CPlusPlus11; } bool isCPlusPlus11() const { return Flags & CPlusPlus11; }
/// isCPlusPlus14 - Language is a C++14 variant (or later). /// isCPlusPlus14 - Language is a C++14 variant (or later).
bool isCPlusPlus14() const { return Flags & CPlusPlus14; } bool isCPlusPlus14() const { return Flags & CPlusPlus14; }
/// isCPlusPlus17 - Language is a C++17 variant (or later). /// isCPlusPlus17 - Language is a C++17 variant (or later).
bool isCPlusPlus17() const { return Flags & CPlusPlus17; } bool isCPlusPlus17() const { return Flags & CPlusPlus17; }
/// isCPlusPlus2a - Language is a post-C++17 variant (or later). /// isCPlusPlus20 - Language is a C++20 variant (or later).
bool isCPlusPlus2a() const { return Flags & CPlusPlus2a; } bool isCPlusPlus20() const { return Flags & CPlusPlus20; }
/// hasDigraphs - Language supports digraphs. /// hasDigraphs - Language supports digraphs.
bool hasDigraphs() const { return Flags & Digraphs; } bool hasDigraphs() const { return Flags & Digraphs; }
/// isGNUMode - Language includes GNU extensions. /// isGNUMode - Language includes GNU extensions.
bool isGNUMode() const { return Flags & GNUMode; } bool isGNUMode() const { return Flags & GNUMode; }
/// hasHexFloats - Language supports hexadecimal float constants. /// hasHexFloats - Language supports hexadecimal float constants.
Show All 16 Lines

clang/include/clang/Basic/LangStandards.def

Show First 20 Lines • Show All 137 Lines • ▼ Show 20 LinesLANGSTANDARD(gnucxx17, "gnu++17",
CXX, "ISO C++ 2017 with amendments and GNU extensions", CXX, "ISO C++ 2017 with amendments and GNU extensions",
LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 | LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
Digraphs | HexFloat | GNUMode) Digraphs | HexFloat | GNUMode)
LANGSTANDARD_ALIAS_DEPR(gnucxx17, "gnu++1z") LANGSTANDARD_ALIAS_DEPR(gnucxx17, "gnu++1z")
LANGSTANDARD(cxx20, "c++20", LANGSTANDARD(cxx20, "c++20",
CXX, "ISO C++ 2020 DIS", CXX, "ISO C++ 2020 DIS",
LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 | LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
CPlusPlus2a | Digraphs | HexFloat) CPlusPlus20 | Digraphs | HexFloat)
LANGSTANDARD_ALIAS_DEPR(cxx20, "c++2a") LANGSTANDARD_ALIAS_DEPR(cxx20, "c++2a")
LANGSTANDARD(gnucxx20, "gnu++20", LANGSTANDARD(gnucxx20, "gnu++20",
CXX, "ISO C++ 2020 DIS with GNU extensions", CXX, "ISO C++ 2020 DIS with GNU extensions",
LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 | LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
CPlusPlus2a | Digraphs | HexFloat | GNUMode) CPlusPlus20 | Digraphs | HexFloat | GNUMode)
LANGSTANDARD_ALIAS_DEPR(gnucxx20, "gnu++2a") LANGSTANDARD_ALIAS_DEPR(gnucxx20, "gnu++2a")
// OpenCL // OpenCL
LANGSTANDARD(opencl10, "cl1.0", LANGSTANDARD(opencl10, "cl1.0",
OpenCL, "OpenCL 1.0", OpenCL, "OpenCL 1.0",
LineComment | C99 | Digraphs | HexFloat | OpenCL) LineComment | C99 | Digraphs | HexFloat | OpenCL)
LANGSTANDARD_ALIAS_DEPR(opencl10, "cl") LANGSTANDARD_ALIAS_DEPR(opencl10, "cl")
Show All 31 Lines

clang/include/clang/Basic/TokenKinds.def

Show All 20 Lines
#define PUNCTUATOR(X,Y) TOK(X) #define PUNCTUATOR(X,Y) TOK(X)
#endif #endif
#ifndef KEYWORD #ifndef KEYWORD
#define KEYWORD(X,Y) TOK(kw_ ## X) #define KEYWORD(X,Y) TOK(kw_ ## X)
#endif #endif
#ifndef CXX11_KEYWORD #ifndef CXX11_KEYWORD
#define CXX11_KEYWORD(X,Y) KEYWORD(X,KEYCXX11|(Y)) #define CXX11_KEYWORD(X,Y) KEYWORD(X,KEYCXX11|(Y))
#endif #endif
#ifndef CXX2A_KEYWORD #ifndef CXX20_KEYWORD
#define CXX2A_KEYWORD(X,Y) KEYWORD(X,KEYCXX2A|(Y)) #define CXX20_KEYWORD(X,Y) KEYWORD(X,KEYCXX20|(Y))
#endif #endif
#ifndef CONCEPTS_KEYWORD #ifndef CONCEPTS_KEYWORD
#define CONCEPTS_KEYWORD(X) CXX2A_KEYWORD(X,KEYCONCEPTS) #define CONCEPTS_KEYWORD(X) CXX20_KEYWORD(X,KEYCONCEPTS)
#endif #endif
#ifndef COROUTINES_KEYWORD #ifndef COROUTINES_KEYWORD
#define COROUTINES_KEYWORD(X) CXX2A_KEYWORD(X,KEYCOROUTINES) #define COROUTINES_KEYWORD(X) CXX20_KEYWORD(X,KEYCOROUTINES)
#endif #endif
#ifndef MODULES_KEYWORD #ifndef MODULES_KEYWORD
#define MODULES_KEYWORD(X) KEYWORD(X,KEYMODULES) #define MODULES_KEYWORD(X) KEYWORD(X,KEYMODULES)
#endif #endif
#ifndef TYPE_TRAIT #ifndef TYPE_TRAIT
#define TYPE_TRAIT(N,I,K) KEYWORD(I,K) #define TYPE_TRAIT(N,I,K) KEYWORD(I,K)
#endif #endif
#ifndef TYPE_TRAIT_1 #ifndef TYPE_TRAIT_1
▲ Show 20 Lines • Show All 194 Lines • ▼ Show 20 Lines
// is a keyword in the implementation namespace that should // is a keyword in the implementation namespace that should
// always be treated as a keyword // always be treated as a keyword
// KEYC99 - This is a keyword introduced to C in C99 // KEYC99 - This is a keyword introduced to C in C99
// KEYC11 - This is a keyword introduced to C in C11 // KEYC11 - This is a keyword introduced to C in C11
// KEYCXX - This is a C++ keyword, or a C++-specific keyword in the // KEYCXX - This is a C++ keyword, or a C++-specific keyword in the
// implementation namespace // implementation namespace
// KEYNOCXX - This is a keyword in every non-C++ dialect. // KEYNOCXX - This is a keyword in every non-C++ dialect.
// KEYCXX11 - This is a C++ keyword introduced to C++ in C++11 // KEYCXX11 - This is a C++ keyword introduced to C++ in C++11
// KEYCXX2A - This is a C++ keyword introduced to C++ in C++2a // KEYCXX20 - This is a C++ keyword introduced to C++ in C++20
// KEYCONCEPTS - This is a keyword if the C++ extensions for concepts // KEYCONCEPTS - This is a keyword if the C++ extensions for concepts
// are enabled. // are enabled.
// KEYMODULES - This is a keyword if the C++ extensions for modules // KEYMODULES - This is a keyword if the C++ extensions for modules
// are enabled. // are enabled.
// KEYGNU - This is a keyword if GNU extensions are enabled // KEYGNU - This is a keyword if GNU extensions are enabled
// KEYMS - This is a keyword if Microsoft extensions are enabled // KEYMS - This is a keyword if Microsoft extensions are enabled
// KEYMSCOMPAT - This is a keyword if Microsoft compatibility mode is enabled // KEYMSCOMPAT - This is a keyword if Microsoft compatibility mode is enabled
// KEYNOMS18 - This is a keyword that must never be enabled under // KEYNOMS18 - This is a keyword that must never be enabled under
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines
CXX11_KEYWORD(char32_t , KEYNOMS18) CXX11_KEYWORD(char32_t , KEYNOMS18)
CXX11_KEYWORD(constexpr , 0) CXX11_KEYWORD(constexpr , 0)
CXX11_KEYWORD(decltype , 0) CXX11_KEYWORD(decltype , 0)
CXX11_KEYWORD(noexcept , 0) CXX11_KEYWORD(noexcept , 0)
CXX11_KEYWORD(nullptr , 0) CXX11_KEYWORD(nullptr , 0)
CXX11_KEYWORD(static_assert , KEYMSCOMPAT) CXX11_KEYWORD(static_assert , KEYMSCOMPAT)
CXX11_KEYWORD(thread_local , 0) CXX11_KEYWORD(thread_local , 0)
// C++2a keywords // C++20 keywords
CONCEPTS_KEYWORD(concept) CONCEPTS_KEYWORD(concept)
CONCEPTS_KEYWORD(requires) CONCEPTS_KEYWORD(requires)
// C++2a / coroutines TS keywords // C++20 / coroutines TS keywords
COROUTINES_KEYWORD(co_await) COROUTINES_KEYWORD(co_await)
COROUTINES_KEYWORD(co_return) COROUTINES_KEYWORD(co_return)
COROUTINES_KEYWORD(co_yield) COROUTINES_KEYWORD(co_yield)
// C++ modules TS keywords // C++ modules TS keywords
MODULES_KEYWORD(module) MODULES_KEYWORD(module)
MODULES_KEYWORD(import) MODULES_KEYWORD(import)
// C++20 keywords. // C++20 keywords.
CXX2A_KEYWORD(char8_t , CHAR8SUPPORT) CXX20_KEYWORD(char8_t , CHAR8SUPPORT)
CXX2A_KEYWORD(consteval , 0) CXX20_KEYWORD(consteval , 0)
CXX2A_KEYWORD(constinit , 0) CXX20_KEYWORD(constinit , 0)
// C11 Extension // C11 Extension
KEYWORD(_Float16 , KEYALL) KEYWORD(_Float16 , KEYALL)
// ISO/IEC JTC1 SC22 WG14 N1169 Extension // ISO/IEC JTC1 SC22 WG14 N1169 Extension
KEYWORD(_Accum , KEYNOCXX) KEYWORD(_Accum , KEYNOCXX)
KEYWORD(_Fract , KEYNOCXX) KEYWORD(_Fract , KEYNOCXX)
KEYWORD(_Sat , KEYNOCXX) KEYWORD(_Sat , KEYNOCXX)
▲ Show 20 Lines • Show All 458 Lines • ▼ Show 20 Lines
#undef CXX_KEYWORD_OPERATOR #undef CXX_KEYWORD_OPERATOR
#undef PPKEYWORD #undef PPKEYWORD
#undef ALIAS #undef ALIAS
#undef TYPE_TRAIT_N #undef TYPE_TRAIT_N
#undef TYPE_TRAIT_2 #undef TYPE_TRAIT_2
#undef TYPE_TRAIT_1 #undef TYPE_TRAIT_1
#undef TYPE_TRAIT #undef TYPE_TRAIT
#undef CONCEPTS_KEYWORD #undef CONCEPTS_KEYWORD
#undef CXX2A_KEYWORD #undef CXX20_KEYWORD
#undef CXX11_KEYWORD #undef CXX11_KEYWORD
#undef KEYWORD #undef KEYWORD
#undef PUNCTUATOR #undef PUNCTUATOR
#undef TOK #undef TOK

clang/lib/AST/DeclCXX.cpp

Show First 20 Lines • Show All 661 Lines • ▼ Show 20 Linesbool CXXRecordDecl::lambdaIsDefaultConstructibleAndAssignable() const {
// defaulted copy and move assignment operators otherwise. // defaulted copy and move assignment operators otherwise.
// //
// C++17 [expr.prim.lambda]p21: // C++17 [expr.prim.lambda]p21:
// The closure type associated with a lambda-expression has no default // The closure type associated with a lambda-expression has no default
// constructor and a deleted copy assignment operator. // constructor and a deleted copy assignment operator.
if (getLambdaCaptureDefault() != LCD_None || if (getLambdaCaptureDefault() != LCD_None ||
getLambdaData().NumCaptures != 0) getLambdaData().NumCaptures != 0)
return false; return false;
return getASTContext().getLangOpts().CPlusPlus2a; return getASTContext().getLangOpts().CPlusPlus20;
} }
void CXXRecordDecl::addedMember(Decl *D) { void CXXRecordDecl::addedMember(Decl *D) {
if (!D->isImplicit() && if (!D->isImplicit() &&
!isa<FieldDecl>(D) && !isa<FieldDecl>(D) &&
!isa<IndirectFieldDecl>(D) && !isa<IndirectFieldDecl>(D) &&
(!isa<TagDecl>(D) || cast<TagDecl>(D)->getTagKind() == TTK_Class || (!isa<TagDecl>(D) || cast<TagDecl>(D)->getTagKind() == TTK_Class ||
cast<TagDecl>(D)->getTagKind() == TTK_Interface)) cast<TagDecl>(D)->getTagKind() == TTK_Interface))
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines if (Constructor->isInheritingConstructor()) {
} }
// C++11 [dcl.init.aggr]p1: DR1518 // C++11 [dcl.init.aggr]p1: DR1518
// An aggregate is an array or a class with no user-provided [or] // An aggregate is an array or a class with no user-provided [or]
// explicit [...] constructors // explicit [...] constructors
// C++20 [dcl.init.aggr]p1: // C++20 [dcl.init.aggr]p1:
// An aggregate is an array or a class with no user-declared [...] // An aggregate is an array or a class with no user-declared [...]
// constructors // constructors
if (getASTContext().getLangOpts().CPlusPlus2a if (getASTContext().getLangOpts().CPlusPlus20
? !Constructor->isImplicit() ? !Constructor->isImplicit()
: (Constructor->isUserProvided() || Constructor->isExplicit())) : (Constructor->isUserProvided() || Constructor->isExplicit()))
data().Aggregate = false; data().Aggregate = false;
} }
} }
// Handle constructors, including those inherited from base classes. // Handle constructors, including those inherited from base classes.
if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(DUnderlying)) { if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(DUnderlying)) {
▲ Show 20 Lines • Show All 489 Lines • ▼ Show 20 Lines if (const auto *RecordTy = T->getAs<RecordType>()) {
if (FieldRec->hasVariantMembers() && if (FieldRec->hasVariantMembers() &&
Field->isAnonymousStructOrUnion()) Field->isAnonymousStructOrUnion())
data().HasVariantMembers = true; data().HasVariantMembers = true;
} }
} else { } else {
// Base element type of field is a non-class type. // Base element type of field is a non-class type.
if (!T->isLiteralType(Context) || if (!T->isLiteralType(Context) ||
(!Field->hasInClassInitializer() && !isUnion() && (!Field->hasInClassInitializer() && !isUnion() &&
!Context.getLangOpts().CPlusPlus2a)) !Context.getLangOpts().CPlusPlus20))
data().DefaultedDefaultConstructorIsConstexpr = false; data().DefaultedDefaultConstructorIsConstexpr = false;
// C++11 [class.copy]p23: // C++11 [class.copy]p23:
// A defaulted copy/move assignment operator for a class X is defined // A defaulted copy/move assignment operator for a class X is defined
// as deleted if X has: // as deleted if X has:
// -- a non-static data member of const non-class type (or array // -- a non-static data member of const non-class type (or array
// thereof) // thereof)
if (T.isConstQualified()) if (T.isConstQualified())
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/AST/DeclTemplate.cpp

Show First 20 Lines • Show All 687 Lines • ▼ Show 20 Lines
NonTypeTemplateParmDecl * NonTypeTemplateParmDecl *
NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC, NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
SourceLocation StartLoc, SourceLocation IdLoc, SourceLocation StartLoc, SourceLocation IdLoc,
unsigned D, unsigned P, IdentifierInfo *Id, unsigned D, unsigned P, IdentifierInfo *Id,
QualType T, bool ParameterPack, QualType T, bool ParameterPack,
TypeSourceInfo *TInfo) { TypeSourceInfo *TInfo) {
AutoType *AT = AutoType *AT =
C.getLangOpts().CPlusPlus2a ? T->getContainedAutoType() : nullptr; C.getLangOpts().CPlusPlus20 ? T->getContainedAutoType() : nullptr;
return new (C, DC, return new (C, DC,
additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
Expr *>(0, Expr *>(0,
AT && AT->isConstrained() ? 1 : 0)) AT && AT->isConstrained() ? 1 : 0))
NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, ParameterPack, NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, ParameterPack,
TInfo); TInfo);
} }
▲ Show 20 Lines • Show All 729 Lines • Show Last 20 Lines

clang/lib/AST/ExprConstant.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
} }
shift_left: shift_left:
// C++11 [expr.shift]p1: Shift width must be less than the bit width of // C++11 [expr.shift]p1: Shift width must be less than the bit width of
// the shifted type. // the shifted type.
unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1); unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
if (SA != RHS) { if (SA != RHS) {
Info.CCEDiag(E, diag::note_constexpr_large_shift) Info.CCEDiag(E, diag::note_constexpr_large_shift)
<< RHS << E->getType() << LHS.getBitWidth(); << RHS << E->getType() << LHS.getBitWidth();
} else if (LHS.isSigned() && !Info.getLangOpts().CPlusPlus2a) { } else if (LHS.isSigned() && !Info.getLangOpts().CPlusPlus20) {
// C++11 [expr.shift]p2: A signed left shift must have a non-negative // C++11 [expr.shift]p2: A signed left shift must have a non-negative
// operand, and must not overflow the corresponding unsigned type. // operand, and must not overflow the corresponding unsigned type.
// C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to // C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to
// E1 x 2^E2 module 2^N. // E1 x 2^E2 module 2^N.
if (LHS.isNegative()) if (LHS.isNegative())
Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS; Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;
else if (LHS.countLeadingZeros() < SA) else if (LHS.countLeadingZeros() < SA)
Info.CCEDiag(E, diag::note_constexpr_lshift_discards); Info.CCEDiag(E, diag::note_constexpr_lshift_discards);
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
if (Declaration->isInvalidDecl()) { if (Declaration->isInvalidDecl()) {
Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr); Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
return false; return false;
} }
// DR1872: An instantiated virtual constexpr function can't be called in a // DR1872: An instantiated virtual constexpr function can't be called in a
// constant expression (prior to C++20). We can still constant-fold such a // constant expression (prior to C++20). We can still constant-fold such a
// call. // call.
if (!Info.Ctx.getLangOpts().CPlusPlus2a && isa<CXXMethodDecl>(Declaration) && if (!Info.Ctx.getLangOpts().CPlusPlus20 && isa<CXXMethodDecl>(Declaration) &&
cast<CXXMethodDecl>(Declaration)->isVirtual()) cast<CXXMethodDecl>(Declaration)->isVirtual())
Info.CCEDiag(CallLoc, diag::note_constexpr_virtual_call); Info.CCEDiag(CallLoc, diag::note_constexpr_virtual_call);
if (Definition && Definition->isInvalidDecl()) { if (Definition && Definition->isInvalidDecl()) {
Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr); Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
return false; return false;
} }
▲ Show 20 Lines • Show All 595 Lines • ▼ Show 20 Lines
assert(This && assert(This &&
(MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())); (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()));
LValue RHS; LValue RHS;
RHS.setFrom(Info.Ctx, ArgValues[0]); RHS.setFrom(Info.Ctx, ArgValues[0]);
APValue RHSValue; APValue RHSValue;
if (!handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(), RHS, if (!handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(), RHS,
RHSValue, MD->getParent()->isUnion())) RHSValue, MD->getParent()->isUnion()))
return false; return false;
if (Info.getLangOpts().CPlusPlus2a && MD->isTrivial() && if (Info.getLangOpts().CPlusPlus20 && MD->isTrivial() &&
!HandleUnionActiveMemberChange(Info, Args[0], *This)) !HandleUnionActiveMemberChange(Info, Args[0], *This))
return false; return false;
if (!handleAssignment(Info, Args[0], *This, MD->getThisType(), if (!handleAssignment(Info, Args[0], *This, MD->getThisType(),
RHSValue)) RHSValue))
return false; return false;
This->moveInto(Result); This->moveInto(Result);
return true; return true;
} else if (MD && isLambdaCallOperator(MD)) { } else if (MD && isLambdaCallOperator(MD)) {
▲ Show 20 Lines • Show All 455 Lines • ▼ Show 20 Lines
LValue &Result) { LValue &Result) {
if (Info.checkingPotentialConstantExpression() || if (Info.checkingPotentialConstantExpression() ||
Info.SpeculativeEvaluationDepth) Info.SpeculativeEvaluationDepth)
return false; return false;
// This is permitted only within a call to std::allocator<T>::allocate. // This is permitted only within a call to std::allocator<T>::allocate.
auto Caller = Info.getStdAllocatorCaller("allocate"); auto Caller = Info.getStdAllocatorCaller("allocate");
if (!Caller) { if (!Caller) {
Info.FFDiag(E->getExprLoc(), Info.getLangOpts().CPlusPlus2a Info.FFDiag(E->getExprLoc(), Info.getLangOpts().CPlusPlus20
? diag::note_constexpr_new_untyped ? diag::note_constexpr_new_untyped
: diag::note_constexpr_new); : diag::note_constexpr_new);
return false; return false;
} }
QualType ElemType = Caller.ElemType; QualType ElemType = Caller.ElemType;
if (ElemType->isIncompleteType() || ElemType->isFunctionType()) { if (ElemType->isIncompleteType() || ElemType->isFunctionType()) {
Info.FFDiag(E->getExprLoc(), Info.FFDiag(E->getExprLoc(),
▲ Show 20 Lines • Show All 765 Lines • ▼ Show 20 Lines
return StmtVisitorTy::Visit(E->getSubExpr()); return StmtVisitorTy::Visit(E->getSubExpr());
} }
bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) { bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {
CCEDiag(E, diag::note_constexpr_invalid_cast) << 0; CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
return static_cast<Derived*>(this)->VisitCastExpr(E); return static_cast<Derived*>(this)->VisitCastExpr(E);
} }
bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) { bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
if (!Info.Ctx.getLangOpts().CPlusPlus2a) if (!Info.Ctx.getLangOpts().CPlusPlus20)
CCEDiag(E, diag::note_constexpr_invalid_cast) << 1; CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
return static_cast<Derived*>(this)->VisitCastExpr(E); return static_cast<Derived*>(this)->VisitCastExpr(E);
} }
bool VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E) { bool VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E) {
return static_cast<Derived*>(this)->VisitCastExpr(E); return static_cast<Derived*>(this)->VisitCastExpr(E);
} }
bool VisitBinaryOperator(const BinaryOperator *E) { bool VisitBinaryOperator(const BinaryOperator *E) {
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines
HandleMemberPointerAccess(Info, BE, ThisVal, false); HandleMemberPointerAccess(Info, BE, ThisVal, false);
if (!D) if (!D)
return false; return false;
Member = dyn_cast<CXXMethodDecl>(D); Member = dyn_cast<CXXMethodDecl>(D);
if (!Member) if (!Member)
return Error(Callee); return Error(Callee);
This = &ThisVal; This = &ThisVal;
} else if (const auto *PDE = dyn_cast<CXXPseudoDestructorExpr>(Callee)) { } else if (const auto *PDE = dyn_cast<CXXPseudoDestructorExpr>(Callee)) {
if (!Info.getLangOpts().CPlusPlus2a) if (!Info.getLangOpts().CPlusPlus20)
Info.CCEDiag(PDE, diag::note_constexpr_pseudo_destructor); Info.CCEDiag(PDE, diag::note_constexpr_pseudo_destructor);
return EvaluateObjectArgument(Info, PDE->getBase(), ThisVal) && return EvaluateObjectArgument(Info, PDE->getBase(), ThisVal) &&
HandleDestruction(Info, PDE, ThisVal, PDE->getDestroyedType()); HandleDestruction(Info, PDE, ThisVal, PDE->getDestroyedType());
} else } else
return Error(Callee); return Error(Callee);
FD = Member; FD = Member;
} else if (CalleeType->isFunctionPointerType()) { } else if (CalleeType->isFunctionPointerType()) {
LValue Call; LValue Call;
▲ Show 20 Lines • Show All 689 Lines • ▼ Show 20 Lines
TypeInfoLValue TypeInfo; TypeInfoLValue TypeInfo;
if (!E->isPotentiallyEvaluated()) { if (!E->isPotentiallyEvaluated()) {
if (E->isTypeOperand()) if (E->isTypeOperand())
TypeInfo = TypeInfoLValue(E->getTypeOperand(Info.Ctx).getTypePtr()); TypeInfo = TypeInfoLValue(E->getTypeOperand(Info.Ctx).getTypePtr());
else else
TypeInfo = TypeInfoLValue(E->getExprOperand()->getType().getTypePtr()); TypeInfo = TypeInfoLValue(E->getExprOperand()->getType().getTypePtr());
} else { } else {
if (!Info.Ctx.getLangOpts().CPlusPlus2a) { if (!Info.Ctx.getLangOpts().CPlusPlus20) {
Info.CCEDiag(E, diag::note_constexpr_typeid_polymorphic) Info.CCEDiag(E, diag::note_constexpr_typeid_polymorphic)
<< E->getExprOperand()->getType() << E->getExprOperand()->getType()
<< E->getExprOperand()->getSourceRange(); << E->getExprOperand()->getSourceRange();
} }
if (!Visit(E->getExprOperand())) if (!Visit(E->getExprOperand()))
return false; return false;
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
if (Info.noteFailure()) if (Info.noteFailure())
Evaluate(NewVal, this->Info, E->getRHS()); Evaluate(NewVal, this->Info, E->getRHS());
return false; return false;
} }
if (!Evaluate(NewVal, this->Info, E->getRHS())) if (!Evaluate(NewVal, this->Info, E->getRHS()))
return false; return false;
if (Info.getLangOpts().CPlusPlus2a && if (Info.getLangOpts().CPlusPlus20 &&
!HandleUnionActiveMemberChange(Info, E->getLHS(), Result)) !HandleUnionActiveMemberChange(Info, E->getLHS(), Result))
return false; return false;
return handleAssignment(this->Info, E, Result, E->getLHS()->getType(), return handleAssignment(this->Info, E, Result, E->getLHS()->getType(),
NewVal); NewVal);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 853 Lines • ▼ Show 20 Lines
APValue &Result, const InitListExpr *ILE, APValue &Result, const InitListExpr *ILE,
QualType AllocType); QualType AllocType);
static bool EvaluateArrayNewConstructExpr(EvalInfo &Info, LValue &This, static bool EvaluateArrayNewConstructExpr(EvalInfo &Info, LValue &This,
APValue &Result, APValue &Result,
const CXXConstructExpr *CCE, const CXXConstructExpr *CCE,
QualType AllocType); QualType AllocType);
bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) { bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {
if (!Info.getLangOpts().CPlusPlus2a) if (!Info.getLangOpts().CPlusPlus20)
Info.CCEDiag(E, diag::note_constexpr_new); Info.CCEDiag(E, diag::note_constexpr_new);
// We cannot speculatively evaluate a delete expression. // We cannot speculatively evaluate a delete expression.
if (Info.SpeculativeEvaluationDepth) if (Info.SpeculativeEvaluationDepth)
return false; return false;
FunctionDecl *OperatorNew = E->getOperatorNew(); FunctionDecl *OperatorNew = E->getOperatorNew();
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
if (Pointer.Designator.Invalid) if (Pointer.Designator.Invalid)
return false; return false;
// Deleting a null pointer has no effect. // Deleting a null pointer has no effect.
if (Pointer.isNullPointer()) { if (Pointer.isNullPointer()) {
// This is the only case where we need to produce an extension warning: // This is the only case where we need to produce an extension warning:
// the only other way we can succeed is if we find a dynamic allocation, // the only other way we can succeed is if we find a dynamic allocation,
// and we will have warned when we allocated it in that case. // and we will have warned when we allocated it in that case.
if (!Info.getLangOpts().CPlusPlus2a) if (!Info.getLangOpts().CPlusPlus20)
Info.CCEDiag(E, diag::note_constexpr_new); Info.CCEDiag(E, diag::note_constexpr_new);
return true; return true;
} }
Optional<DynAlloc *> Alloc = CheckDeleteKind( Optional<DynAlloc *> Alloc = CheckDeleteKind(
Info, E, Pointer, E->isArrayForm() ? DynAlloc::ArrayNew : DynAlloc::New); Info, E, Pointer, E->isArrayForm() ? DynAlloc::ArrayNew : DynAlloc::New);
if (!Alloc) if (!Alloc)
return false; return false;
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/AST/Interp/Interp.h

Show First 20 Lines • Show All 863 Lines • ▼ Show 20 Linesinline bool ShiftRight(InterpState &S, CodePtr OpPC, const T &V, unsigned RHS) {
} else { } else {
S.Stk.push<T>(T::from(V >> RHS, V.bitWidth())); S.Stk.push<T>(T::from(V >> RHS, V.bitWidth()));
} }
return true; return true;
} }
template <PrimType TL, PrimType TR, typename T = typename PrimConv<TL>::T> template <PrimType TL, PrimType TR, typename T = typename PrimConv<TL>::T>
inline bool ShiftLeft(InterpState &S, CodePtr OpPC, const T &V, unsigned RHS) { inline bool ShiftLeft(InterpState &S, CodePtr OpPC, const T &V, unsigned RHS) {
if (V.isSigned() && !S.getLangOpts().CPlusPlus2a) { if (V.isSigned() && !S.getLangOpts().CPlusPlus20) {
// C++11 [expr.shift]p2: A signed left shift must have a non-negative // C++11 [expr.shift]p2: A signed left shift must have a non-negative
// operand, and must not overflow the corresponding unsigned type. // operand, and must not overflow the corresponding unsigned type.
// C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to // C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to
// E1 x 2^E2 module 2^N. // E1 x 2^E2 module 2^N.
if (V.isNegative()) { if (V.isNegative()) {
const Expr *E = S.Current->getExpr(OpPC); const Expr *E = S.Current->getExpr(OpPC);
S.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << V.toAPSInt(); S.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << V.toAPSInt();
} else if (V.countLeadingZeros() < RHS) { } else if (V.countLeadingZeros() < RHS) {
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

clang/lib/AST/Interp/Interp.cpp

Show First 20 Lines • Show All 328 Lines • ▼ Show 20 Lines if (!CheckRange(S, OpPC, Ptr, AK_Assign))
return false; return false;
return true; return true;
} }
bool CheckCallable(InterpState &S, CodePtr OpPC, Function *F) { bool CheckCallable(InterpState &S, CodePtr OpPC, Function *F) {
const SourceLocation &Loc = S.Current->getLocation(OpPC); const SourceLocation &Loc = S.Current->getLocation(OpPC);
if (F->isVirtual()) { if (F->isVirtual()) {
if (!S.getLangOpts().CPlusPlus2a) { if (!S.getLangOpts().CPlusPlus20) {
S.CCEDiag(Loc, diag::note_constexpr_virtual_call); S.CCEDiag(Loc, diag::note_constexpr_virtual_call);
return false; return false;
} }
} }
if (!F->isConstexpr()) { if (!F->isConstexpr()) {
if (S.getLangOpts().CPlusPlus11) { if (S.getLangOpts().CPlusPlus11) {
const FunctionDecl *DiagDecl = F->getDecl(); const FunctionDecl *DiagDecl = F->getDecl();
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

clang/lib/Basic/IdentifierTable.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines enum {
WCHARSUPPORT = 0x2000, WCHARSUPPORT = 0x2000,
HALFSUPPORT = 0x4000, HALFSUPPORT = 0x4000,
CHAR8SUPPORT = 0x8000, CHAR8SUPPORT = 0x8000,
KEYCONCEPTS = 0x10000, KEYCONCEPTS = 0x10000,
KEYOBJC = 0x20000, KEYOBJC = 0x20000,
KEYZVECTOR = 0x40000, KEYZVECTOR = 0x40000,
KEYCOROUTINES = 0x80000, KEYCOROUTINES = 0x80000,
KEYMODULES = 0x100000, KEYMODULES = 0x100000,
KEYCXX2A = 0x200000, KEYCXX20 = 0x200000,
KEYOPENCLCXX = 0x400000, KEYOPENCLCXX = 0x400000,
KEYMSCOMPAT = 0x800000, KEYMSCOMPAT = 0x800000,
KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX2A, KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX20,
KEYALL = (0xffffff & ~KEYNOMS18 & KEYALL = (0xffffff & ~KEYNOMS18 &
~KEYNOOPENCL) // KEYNOMS18 and KEYNOOPENCL are used to exclude. ~KEYNOOPENCL) // KEYNOMS18 and KEYNOOPENCL are used to exclude.
}; };
/// How a keyword is treated in the selected standard. /// How a keyword is treated in the selected standard.
enum KeywordStatus { enum KeywordStatus {
KS_Disabled, // Disabled KS_Disabled, // Disabled
KS_Extension, // Is an extension KS_Extension, // Is an extension
KS_Enabled, // Enabled KS_Enabled, // Enabled
KS_Future // Is a keyword in future standard KS_Future // Is a keyword in future standard
}; };
} // namespace } // namespace
/// Translates flags as specified in TokenKinds.def into keyword status /// Translates flags as specified in TokenKinds.def into keyword status
/// in the given language standard. /// in the given language standard.
static KeywordStatus getKeywordStatus(const LangOptions &LangOpts, static KeywordStatus getKeywordStatus(const LangOptions &LangOpts,
unsigned Flags) { unsigned Flags) {
if (Flags == KEYALL) return KS_Enabled; if (Flags == KEYALL) return KS_Enabled;
if (LangOpts.CPlusPlus && (Flags & KEYCXX)) return KS_Enabled; if (LangOpts.CPlusPlus && (Flags & KEYCXX)) return KS_Enabled;
if (LangOpts.CPlusPlus11 && (Flags & KEYCXX11)) return KS_Enabled; if (LangOpts.CPlusPlus11 && (Flags & KEYCXX11)) return KS_Enabled;
if (LangOpts.CPlusPlus2a && (Flags & KEYCXX2A)) return KS_Enabled; if (LangOpts.CPlusPlus20 && (Flags & KEYCXX20)) return KS_Enabled;
if (LangOpts.C99 && (Flags & KEYC99)) return KS_Enabled; if (LangOpts.C99 && (Flags & KEYC99)) return KS_Enabled;
if (LangOpts.GNUKeywords && (Flags & KEYGNU)) return KS_Extension; if (LangOpts.GNUKeywords && (Flags & KEYGNU)) return KS_Extension;
if (LangOpts.MicrosoftExt && (Flags & KEYMS)) return KS_Extension; if (LangOpts.MicrosoftExt && (Flags & KEYMS)) return KS_Extension;
if (LangOpts.MSVCCompat && (Flags & KEYMSCOMPAT)) return KS_Enabled; if (LangOpts.MSVCCompat && (Flags & KEYMSCOMPAT)) return KS_Enabled;
if (LangOpts.Borland && (Flags & KEYBORLAND)) return KS_Extension; if (LangOpts.Borland && (Flags & KEYBORLAND)) return KS_Extension;
if (LangOpts.Bool && (Flags & BOOLSUPPORT)) return KS_Enabled; if (LangOpts.Bool && (Flags & BOOLSUPPORT)) return KS_Enabled;
if (LangOpts.Half && (Flags & HALFSUPPORT)) return KS_Enabled; if (LangOpts.Half && (Flags & HALFSUPPORT)) return KS_Enabled;
if (LangOpts.WChar && (Flags & WCHARSUPPORT)) return KS_Enabled; if (LangOpts.WChar && (Flags & WCHARSUPPORT)) return KS_Enabled;
if (LangOpts.Char8 && (Flags & CHAR8SUPPORT)) return KS_Enabled; if (LangOpts.Char8 && (Flags & CHAR8SUPPORT)) return KS_Enabled;
if (LangOpts.AltiVec && (Flags & KEYALTIVEC)) return KS_Enabled; if (LangOpts.AltiVec && (Flags & KEYALTIVEC)) return KS_Enabled;
if (LangOpts.ZVector && (Flags & KEYZVECTOR)) return KS_Enabled; if (LangOpts.ZVector && (Flags & KEYZVECTOR)) return KS_Enabled;
if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLC)) if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLC))
return KS_Enabled; return KS_Enabled;
if (LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLCXX)) return KS_Enabled; if (LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLCXX)) return KS_Enabled;
if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX)) return KS_Enabled; if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX)) return KS_Enabled;
if (LangOpts.C11 && (Flags & KEYC11)) return KS_Enabled; if (LangOpts.C11 && (Flags & KEYC11)) return KS_Enabled;
// We treat bridge casts as objective-C keywords so we can warn on them // We treat bridge casts as objective-C keywords so we can warn on them
// in non-arc mode. // in non-arc mode.
if (LangOpts.ObjC && (Flags & KEYOBJC)) return KS_Enabled; if (LangOpts.ObjC && (Flags & KEYOBJC)) return KS_Enabled;
if (LangOpts.CPlusPlus2a && (Flags & KEYCONCEPTS)) return KS_Enabled; if (LangOpts.CPlusPlus20 && (Flags & KEYCONCEPTS)) return KS_Enabled;
if (LangOpts.Coroutines && (Flags & KEYCOROUTINES)) return KS_Enabled; if (LangOpts.Coroutines && (Flags & KEYCOROUTINES)) return KS_Enabled;
if (LangOpts.ModulesTS && (Flags & KEYMODULES)) return KS_Enabled; if (LangOpts.ModulesTS && (Flags & KEYMODULES)) return KS_Enabled;
if (LangOpts.CPlusPlus && (Flags & KEYALLCXX)) return KS_Future; if (LangOpts.CPlusPlus && (Flags & KEYALLCXX)) return KS_Future;
return KS_Disabled; return KS_Disabled;
} }
/// AddKeyword - This method is used to associate a token ID with specific /// AddKeyword - This method is used to associate a token ID with specific
/// identifiers because they are language keywords. This causes the lexer to /// identifiers because they are language keywords. This causes the lexer to
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines
bool IdentifierInfo::isCPlusPlusKeyword(const LangOptions &LangOpts) const { bool IdentifierInfo::isCPlusPlusKeyword(const LangOptions &LangOpts) const {
if (!LangOpts.CPlusPlus || !isKeyword(LangOpts)) if (!LangOpts.CPlusPlus || !isKeyword(LangOpts))
return false; return false;
// This is a C++ keyword if this identifier is not a keyword when checked // This is a C++ keyword if this identifier is not a keyword when checked
// using LangOptions without C++ support. // using LangOptions without C++ support.
LangOptions LangOptsNoCPP = LangOpts; LangOptions LangOptsNoCPP = LangOpts;
LangOptsNoCPP.CPlusPlus = false; LangOptsNoCPP.CPlusPlus = false;
LangOptsNoCPP.CPlusPlus11 = false; LangOptsNoCPP.CPlusPlus11 = false;
LangOptsNoCPP.CPlusPlus2a = false; LangOptsNoCPP.CPlusPlus20 = false;
return !isKeyword(LangOptsNoCPP); return !isKeyword(LangOptsNoCPP);
} }
tok::PPKeywordKind IdentifierInfo::getPPKeywordID() const { tok::PPKeywordKind IdentifierInfo::getPPKeywordID() const {
// We use a perfect hash function here involving the length of the keyword, // We use a perfect hash function here involving the length of the keyword,
// the first and third character. For preprocessor ID's there are no // the first and third character. For preprocessor ID's there are no
// collisions (if there were, the switch below would complain about duplicate // collisions (if there were, the switch below would complain about duplicate
// case values). Note that this depends on 'if' being null terminated. // case values). Note that this depends on 'if' being null terminated.
▲ Show 20 Lines • Show All 444 Lines • Show Last 20 Lines

clang/lib/Basic/Targets/OSTargets.cpp

Show First 20 Lines • Show All 173 Lines • ▼ Show 20 Lines if (Opts.MSCompatibilityVersion) {
Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion)); Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
// FIXME We cannot encode the revision information into 32-bits // FIXME We cannot encode the revision information into 32-bits
Builder.defineMacro("_MSC_BUILD", Twine(1)); Builder.defineMacro("_MSC_BUILD", Twine(1));
if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015))
Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1)); Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) { if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) {
if (Opts.CPlusPlus2a) if (Opts.CPlusPlus20)
Builder.defineMacro("_MSVC_LANG", "201705L"); Builder.defineMacro("_MSVC_LANG", "201705L");
else if (Opts.CPlusPlus17) else if (Opts.CPlusPlus17)
Builder.defineMacro("_MSVC_LANG", "201703L"); Builder.defineMacro("_MSVC_LANG", "201703L");
else if (Opts.CPlusPlus14) else if (Opts.CPlusPlus14)
Builder.defineMacro("_MSVC_LANG", "201402L"); Builder.defineMacro("_MSVC_LANG", "201402L");
} }
} }
Show All 27 Lines

clang/lib/CodeGen/CGExprScalar.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
// RHS to the same size as the LHS. // RHS to the same size as the LHS.
Value *RHS = Ops.RHS; Value *RHS = Ops.RHS;
if (Ops.LHS->getType() != RHS->getType()) if (Ops.LHS->getType() != RHS->getType())
RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
bool SanitizeBase = CGF.SanOpts.has(SanitizerKind::ShiftBase) && bool SanitizeBase = CGF.SanOpts.has(SanitizerKind::ShiftBase) &&
Ops.Ty->hasSignedIntegerRepresentation() && Ops.Ty->hasSignedIntegerRepresentation() &&
!CGF.getLangOpts().isSignedOverflowDefined() && !CGF.getLangOpts().isSignedOverflowDefined() &&
!CGF.getLangOpts().CPlusPlus2a; !CGF.getLangOpts().CPlusPlus20;
bool SanitizeExponent = CGF.SanOpts.has(SanitizerKind::ShiftExponent); bool SanitizeExponent = CGF.SanOpts.has(SanitizerKind::ShiftExponent);
// OpenCL 6.3j: shift values are effectively % word size of LHS. // OpenCL 6.3j: shift values are effectively % word size of LHS.
if (CGF.getLangOpts().OpenCL) if (CGF.getLangOpts().OpenCL)
RHS = ConstrainShiftValue(Ops.LHS, RHS, "shl.mask"); RHS = ConstrainShiftValue(Ops.LHS, RHS, "shl.mask");
else if ((SanitizeBase || SanitizeExponent) && else if ((SanitizeBase || SanitizeExponent) &&
isa<llvm::IntegerType>(Ops.LHS->getType())) { isa<llvm::IntegerType>(Ops.LHS->getType())) {
CodeGenFunction::SanitizerScope SanScope(&CGF); CodeGenFunction::SanitizerScope SanScope(&CGF);
SmallVector<std::pair<Value *, SanitizerMask>, 2> Checks; SmallVector<std::pair<Value *, SanitizerMask>, 2> Checks;
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/CrossTU/CrossTranslationUnit.cpp

Show First 20 Lines • Show All 282 Lines • ▼ Show 20 Linesllvm::Expected<const T *> CrossTranslationUnitContext::getCrossTUDefinitionImpl(
// { // ... // { // ...
// }; // };
// This class template would create ODR errors during merging the two units, // This class template would create ODR errors during merging the two units,
// since in one translation unit the class template has a base class, however // since in one translation unit the class template has a base class, however
// in the other unit it has none. // in the other unit it has none.
if (LangTo.CPlusPlus11 != LangFrom.CPlusPlus11 || if (LangTo.CPlusPlus11 != LangFrom.CPlusPlus11 ||
LangTo.CPlusPlus14 != LangFrom.CPlusPlus14 || LangTo.CPlusPlus14 != LangFrom.CPlusPlus14 ||
LangTo.CPlusPlus17 != LangFrom.CPlusPlus17 || LangTo.CPlusPlus17 != LangFrom.CPlusPlus17 ||
LangTo.CPlusPlus2a != LangFrom.CPlusPlus2a) { LangTo.CPlusPlus20 != LangFrom.CPlusPlus20) {
++NumLangDialectMismatch; ++NumLangDialectMismatch;
return llvm::make_error<IndexError>( return llvm::make_error<IndexError>(
index_error_code::lang_dialect_mismatch); index_error_code::lang_dialect_mismatch);
} }
TranslationUnitDecl *TU = Unit->getASTContext().getTranslationUnitDecl(); TranslationUnitDecl *TU = Unit->getASTContext().getTranslationUnitDecl();
if (const T *ResultDecl = findDefInDeclContext<T>(TU, *LookupName)) if (const T *ResultDecl = findDefInDeclContext<T>(TU, *LookupName))
return importDefinition(ResultDecl, Unit); return importDefinition(ResultDecl, Unit);
▲ Show 20 Lines • Show All 289 Lines • Show Last 20 Lines

clang/lib/Format/Format.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
if (LexingStd == FormatStyle::LS_Auto) if (LexingStd == FormatStyle::LS_Auto)
LexingStd = FormatStyle::LS_Latest; LexingStd = FormatStyle::LS_Latest;
if (LexingStd == FormatStyle::LS_Latest) if (LexingStd == FormatStyle::LS_Latest)
LexingStd = FormatStyle::LS_Cpp20; LexingStd = FormatStyle::LS_Cpp20;
LangOpts.CPlusPlus = 1; LangOpts.CPlusPlus = 1;
LangOpts.CPlusPlus11 = LexingStd >= FormatStyle::LS_Cpp11; LangOpts.CPlusPlus11 = LexingStd >= FormatStyle::LS_Cpp11;
LangOpts.CPlusPlus14 = LexingStd >= FormatStyle::LS_Cpp14; LangOpts.CPlusPlus14 = LexingStd >= FormatStyle::LS_Cpp14;
LangOpts.CPlusPlus17 = LexingStd >= FormatStyle::LS_Cpp17; LangOpts.CPlusPlus17 = LexingStd >= FormatStyle::LS_Cpp17;
LangOpts.CPlusPlus2a = LexingStd >= FormatStyle::LS_Cpp20; LangOpts.CPlusPlus20 = LexingStd >= FormatStyle::LS_Cpp20;
LangOpts.LineComment = 1; LangOpts.LineComment = 1;
bool AlternativeOperators = Style.isCpp(); bool AlternativeOperators = Style.isCpp();
LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0; LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
LangOpts.Bool = 1; LangOpts.Bool = 1;
LangOpts.ObjC = 1; LangOpts.ObjC = 1;
LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally. LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally.
LangOpts.DeclSpecKeyword = 1; // To get __declspec. LangOpts.DeclSpecKeyword = 1; // To get __declspec.
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

clang/lib/Frontend/CompilerInvocation.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
Opts.C99 = Std.isC99(); Opts.C99 = Std.isC99();
Opts.C11 = Std.isC11(); Opts.C11 = Std.isC11();
Opts.C17 = Std.isC17(); Opts.C17 = Std.isC17();
Opts.C2x = Std.isC2x(); Opts.C2x = Std.isC2x();
Opts.CPlusPlus = Std.isCPlusPlus(); Opts.CPlusPlus = Std.isCPlusPlus();
Opts.CPlusPlus11 = Std.isCPlusPlus11(); Opts.CPlusPlus11 = Std.isCPlusPlus11();
Opts.CPlusPlus14 = Std.isCPlusPlus14(); Opts.CPlusPlus14 = Std.isCPlusPlus14();
Opts.CPlusPlus17 = Std.isCPlusPlus17(); Opts.CPlusPlus17 = Std.isCPlusPlus17();
Opts.CPlusPlus2a = Std.isCPlusPlus2a(); Opts.CPlusPlus20 = Std.isCPlusPlus20();
Opts.Digraphs = Std.hasDigraphs(); Opts.Digraphs = Std.hasDigraphs();
Opts.GNUMode = Std.isGNUMode(); Opts.GNUMode = Std.isGNUMode();
Opts.GNUInline = !Opts.C99 && !Opts.CPlusPlus; Opts.GNUInline = !Opts.C99 && !Opts.CPlusPlus;
Opts.GNUCVersion = 0; Opts.GNUCVersion = 0;
Opts.HexFloats = Std.hasHexFloats(); Opts.HexFloats = Std.hasHexFloats();
Opts.ImplicitInt = Std.hasImplicitInt(); Opts.ImplicitInt = Std.hasImplicitInt();
// Set OpenCL Version. // Set OpenCL Version.
▲ Show 20 Lines • Show All 512 Lines • ▼ Show 20 Lines
Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind); Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind);
Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp); Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti); Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data); Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
&& Opts.OpenCLVersion == 200); && Opts.OpenCLVersion == 200);
Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional); Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
Opts.Coroutines = Opts.CPlusPlus2a || Args.hasArg(OPT_fcoroutines_ts); Opts.Coroutines = Opts.CPlusPlus20 || Args.hasArg(OPT_fcoroutines_ts);
Opts.ConvergentFunctions = Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || Opts.ConvergentFunctions = Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
Args.hasArg(OPT_fconvergent_functions); Args.hasArg(OPT_fconvergent_functions);
Opts.DoubleSquareBracketAttributes = Opts.DoubleSquareBracketAttributes =
Args.hasFlag(OPT_fdouble_square_bracket_attributes, Args.hasFlag(OPT_fdouble_square_bracket_attributes,
OPT_fno_double_square_bracket_attributes, OPT_fno_double_square_bracket_attributes,
Opts.DoubleSquareBracketAttributes); Opts.DoubleSquareBracketAttributes);
Opts.CPlusPlusModules = Opts.CPlusPlus2a; Opts.CPlusPlusModules = Opts.CPlusPlus20;
Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts); Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts);
Opts.Modules = Opts.Modules =
Args.hasArg(OPT_fmodules) || Opts.ModulesTS || Opts.CPlusPlusModules; Args.hasArg(OPT_fmodules) || Opts.ModulesTS || Opts.CPlusPlusModules;
Opts.ModulesStrictDeclUse = Args.hasArg(OPT_fmodules_strict_decluse); Opts.ModulesStrictDeclUse = Args.hasArg(OPT_fmodules_strict_decluse);
Opts.ModulesDeclUse = Opts.ModulesDeclUse =
Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse; Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse;
// FIXME: We only need this in C++ modules / Modules TS if we might textually // FIXME: We only need this in C++ modules / Modules TS if we might textually
// enter a different module (eg, when building a header unit). // enter a different module (eg, when building a header unit).
Opts.ModulesLocalVisibility = Opts.ModulesLocalVisibility =
Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS || Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS ||
Opts.CPlusPlusModules; Opts.CPlusPlusModules;
Opts.ModulesCodegen = Args.hasArg(OPT_fmodules_codegen); Opts.ModulesCodegen = Args.hasArg(OPT_fmodules_codegen);
Opts.ModulesDebugInfo = Args.hasArg(OPT_fmodules_debuginfo); Opts.ModulesDebugInfo = Args.hasArg(OPT_fmodules_debuginfo);
Opts.ModulesSearchAll = Opts.Modules && Opts.ModulesSearchAll = Opts.Modules &&
!Args.hasArg(OPT_fno_modules_search_all) && !Args.hasArg(OPT_fno_modules_search_all) &&
Args.hasArg(OPT_fmodules_search_all); Args.hasArg(OPT_fmodules_search_all);
Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery); Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery);
Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules); Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules);
Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char); Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar); Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
Opts.Char8 = Args.hasFlag(OPT_fchar8__t, OPT_fno_char8__t, Opts.CPlusPlus2a); Opts.Char8 = Args.hasFlag(OPT_fchar8__t, OPT_fno_char8__t, Opts.CPlusPlus20);
if (const Arg *A = Args.getLastArg(OPT_fwchar_type_EQ)) { if (const Arg *A = Args.getLastArg(OPT_fwchar_type_EQ)) {
Opts.WCharSize = llvm::StringSwitch<unsigned>(A->getValue()) Opts.WCharSize = llvm::StringSwitch<unsigned>(A->getValue())
.Case("char", 1) .Case("char", 1)
.Case("short", 2) .Case("short", 2)
.Case("int", 4) .Case("int", 4)
.Default(0); .Default(0);
if (Opts.WCharSize == 0) if (Opts.WCharSize == 0)
Diags.Report(diag::err_fe_invalid_wchar_type) << A->getValue(); Diags.Report(diag::err_fe_invalid_wchar_type) << A->getValue();
▲ Show 20 Lines • Show All 982 Lines • Show Last 20 Lines

clang/lib/Frontend/InitPreprocessor.cpp

Show First 20 Lines • Show All 371 Lines • ▼ Show 20 Lines else if (LangOpts.C11)
Builder.defineMacro("__STDC_VERSION__", "201112L"); Builder.defineMacro("__STDC_VERSION__", "201112L");
else if (LangOpts.C99) else if (LangOpts.C99)
Builder.defineMacro("__STDC_VERSION__", "199901L"); Builder.defineMacro("__STDC_VERSION__", "199901L");
else if (!LangOpts.GNUMode && LangOpts.Digraphs) else if (!LangOpts.GNUMode && LangOpts.Digraphs)
Builder.defineMacro("__STDC_VERSION__", "199409L"); Builder.defineMacro("__STDC_VERSION__", "199409L");
} else { } else {
// -- __cplusplus // -- __cplusplus
// [C++20] The integer literal 202002L. // [C++20] The integer literal 202002L.
if (LangOpts.CPlusPlus2a) if (LangOpts.CPlusPlus20)
Builder.defineMacro("__cplusplus", "202002L"); Builder.defineMacro("__cplusplus", "202002L");
// [C++17] The integer literal 201703L. // [C++17] The integer literal 201703L.
else if (LangOpts.CPlusPlus17) else if (LangOpts.CPlusPlus17)
Builder.defineMacro("__cplusplus", "201703L"); Builder.defineMacro("__cplusplus", "201703L");
// [C++14] The name __cplusplus is defined to the value 201402L when // [C++14] The name __cplusplus is defined to the value 201402L when
// compiling a C++ translation unit. // compiling a C++ translation unit.
else if (LangOpts.CPlusPlus14) else if (LangOpts.CPlusPlus14)
Builder.defineMacro("__cplusplus", "201402L"); Builder.defineMacro("__cplusplus", "201402L");
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Linesstatic void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts,
// C++11 features. // C++11 features.
if (LangOpts.CPlusPlus11) { if (LangOpts.CPlusPlus11) {
Builder.defineMacro("__cpp_unicode_characters", "200704L"); Builder.defineMacro("__cpp_unicode_characters", "200704L");
Builder.defineMacro("__cpp_raw_strings", "200710L"); Builder.defineMacro("__cpp_raw_strings", "200710L");
Builder.defineMacro("__cpp_unicode_literals", "200710L"); Builder.defineMacro("__cpp_unicode_literals", "200710L");
Builder.defineMacro("__cpp_user_defined_literals", "200809L"); Builder.defineMacro("__cpp_user_defined_literals", "200809L");
Builder.defineMacro("__cpp_lambdas", "200907L"); Builder.defineMacro("__cpp_lambdas", "200907L");
Builder.defineMacro("__cpp_constexpr", Builder.defineMacro("__cpp_constexpr",
LangOpts.CPlusPlus2a ? "201907L" : LangOpts.CPlusPlus20 ? "201907L" :
LangOpts.CPlusPlus17 ? "201603L" : LangOpts.CPlusPlus17 ? "201603L" :
LangOpts.CPlusPlus14 ? "201304L" : "200704"); LangOpts.CPlusPlus14 ? "201304L" : "200704");
Builder.defineMacro("__cpp_constexpr_in_decltype", "201711L"); Builder.defineMacro("__cpp_constexpr_in_decltype", "201711L");
Builder.defineMacro("__cpp_range_based_for", Builder.defineMacro("__cpp_range_based_for",
LangOpts.CPlusPlus17 ? "201603L" : "200907"); LangOpts.CPlusPlus17 ? "201603L" : "200907");
Builder.defineMacro("__cpp_static_assert", Builder.defineMacro("__cpp_static_assert",
LangOpts.CPlusPlus17 ? "201411L" : "200410"); LangOpts.CPlusPlus17 ? "201411L" : "200410");
Builder.defineMacro("__cpp_decltype", "200707L"); Builder.defineMacro("__cpp_decltype", "200707L");
Show All 10 Linesstatic void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts,
if (LangOpts.ThreadsafeStatics) if (LangOpts.ThreadsafeStatics)
Builder.defineMacro("__cpp_threadsafe_static_init", "200806L"); Builder.defineMacro("__cpp_threadsafe_static_init", "200806L");
// C++14 features. // C++14 features.
if (LangOpts.CPlusPlus14) { if (LangOpts.CPlusPlus14) {
Builder.defineMacro("__cpp_binary_literals", "201304L"); Builder.defineMacro("__cpp_binary_literals", "201304L");
Builder.defineMacro("__cpp_digit_separators", "201309L"); Builder.defineMacro("__cpp_digit_separators", "201309L");
Builder.defineMacro("__cpp_init_captures", Builder.defineMacro("__cpp_init_captures",
LangOpts.CPlusPlus2a ? "201803L" : "201304L"); LangOpts.CPlusPlus20 ? "201803L" : "201304L");
Builder.defineMacro("__cpp_generic_lambdas", Builder.defineMacro("__cpp_generic_lambdas",
LangOpts.CPlusPlus2a ? "201707L" : "201304L"); LangOpts.CPlusPlus20 ? "201707L" : "201304L");
Builder.defineMacro("__cpp_decltype_auto", "201304L"); Builder.defineMacro("__cpp_decltype_auto", "201304L");
Builder.defineMacro("__cpp_return_type_deduction", "201304L"); Builder.defineMacro("__cpp_return_type_deduction", "201304L");
Builder.defineMacro("__cpp_aggregate_nsdmi", "201304L"); Builder.defineMacro("__cpp_aggregate_nsdmi", "201304L");
Builder.defineMacro("__cpp_variable_templates", "201304L"); Builder.defineMacro("__cpp_variable_templates", "201304L");
} }
if (LangOpts.SizedDeallocation) if (LangOpts.SizedDeallocation)
Builder.defineMacro("__cpp_sized_deallocation", "201309L"); Builder.defineMacro("__cpp_sized_deallocation", "201309L");
Show All 19 Lines if (LangOpts.CPlusPlus17) {
Builder.defineMacro("__cpp_nontype_template_parameter_auto", "201606L"); Builder.defineMacro("__cpp_nontype_template_parameter_auto", "201606L");
} }
if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable) if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable)
Builder.defineMacro("__cpp_aligned_new", "201606L"); Builder.defineMacro("__cpp_aligned_new", "201606L");
if (LangOpts.RelaxedTemplateTemplateArgs) if (LangOpts.RelaxedTemplateTemplateArgs)
Builder.defineMacro("__cpp_template_template_args", "201611L"); Builder.defineMacro("__cpp_template_template_args", "201611L");
// C++20 features. // C++20 features.
if (LangOpts.CPlusPlus2a) { if (LangOpts.CPlusPlus20) {
//Builder.defineMacro("__cpp_aggregate_paren_init", "201902L"); //Builder.defineMacro("__cpp_aggregate_paren_init", "201902L");
Builder.defineMacro("__cpp_concepts", "201907L"); Builder.defineMacro("__cpp_concepts", "201907L");
Builder.defineMacro("__cpp_conditional_explicit", "201806L"); Builder.defineMacro("__cpp_conditional_explicit", "201806L");
//Builder.defineMacro("__cpp_consteval", "201811L"); //Builder.defineMacro("__cpp_consteval", "201811L");
Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L"); Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L");
Builder.defineMacro("__cpp_constinit", "201907L"); Builder.defineMacro("__cpp_constinit", "201907L");
//Builder.defineMacro("__cpp_coroutines", "201902L"); //Builder.defineMacro("__cpp_coroutines", "201902L");
Builder.defineMacro("__cpp_designated_initializers", "201707L"); Builder.defineMacro("__cpp_designated_initializers", "201707L");
▲ Show 20 Lines • Show All 650 Lines • Show Last 20 Lines

clang/lib/Lex/Lexer.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
SizeTmp2, Result); SizeTmp2, Result);
} else { } else {
CurPtr = ConsumeChar(CurPtr, SizeTmp, Result); CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
Kind = tok::lessless; Kind = tok::lessless;
} }
} else if (Char == '=') { } else if (Char == '=') {
char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2); char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
if (After == '>') { if (After == '>') {
if (getLangOpts().CPlusPlus2a) { if (getLangOpts().CPlusPlus20) {
if (!isLexingRawMode()) if (!isLexingRawMode())
Diag(BufferPtr, diag::warn_cxx17_compat_spaceship); Diag(BufferPtr, diag::warn_cxx17_compat_spaceship);
CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result), CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
SizeTmp2, Result); SizeTmp2, Result);
Kind = tok::spaceship; Kind = tok::spaceship;
break; break;
} }
// Suggest adding a space between the '<=' and the '>' to avoid a // Suggest adding a space between the '<=' and the '>' to avoid a
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

clang/lib/Lex/LiteralSupport.cpp

Show First 20 Lines • Show All 810 Lines • ▼ Show 20 Linesbool NumericLiteralParser::isValidUDSuffix(const LangOptions &LangOpts,
// In C++14, "s", "h", "min", "ms", "us", and "ns" are used in the library. // In C++14, "s", "h", "min", "ms", "us", and "ns" are used in the library.
// Per tweaked N3660, "il", "i", and "if" are also used in the library. // Per tweaked N3660, "il", "i", and "if" are also used in the library.
// In C++2a "d" and "y" are used in the library. // In C++2a "d" and "y" are used in the library.
return llvm::StringSwitch<bool>(Suffix) return llvm::StringSwitch<bool>(Suffix)
.Cases("h", "min", "s", true) .Cases("h", "min", "s", true)
.Cases("ms", "us", "ns", true) .Cases("ms", "us", "ns", true)
.Cases("il", "i", "if", true) .Cases("il", "i", "if", true)
.Cases("d", "y", LangOpts.CPlusPlus2a) .Cases("d", "y", LangOpts.CPlusPlus20)
.Default(false); .Default(false);
} }
void NumericLiteralParser::checkSeparator(SourceLocation TokLoc, void NumericLiteralParser::checkSeparator(SourceLocation TokLoc,
const char *Pos, const char *Pos,
CheckSeparatorKind IsAfterDigits) { CheckSeparatorKind IsAfterDigits) {
if (IsAfterDigits == CSK_AfterDigits) { if (IsAfterDigits == CSK_AfterDigits) {
if (Pos == ThisTokBegin) if (Pos == ThisTokBegin)
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Lex/Preprocessor.cpp

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 LinesPreprocessor::Preprocessor(std::shared_ptr<PreprocessorOptions> PPOpts,
ReadMacrosFromExternalSource = false; ReadMacrosFromExternalSource = false;
BuiltinInfo = std::make_unique<Builtin::Context>(); BuiltinInfo = std::make_unique<Builtin::Context>();
// "Poison" __VA_ARGS__, __VA_OPT__ which can only appear in the expansion of // "Poison" __VA_ARGS__, __VA_OPT__ which can only appear in the expansion of
// a macro. They get unpoisoned where it is allowed. // a macro. They get unpoisoned where it is allowed.
(Ident__VA_ARGS__ = getIdentifierInfo("__VA_ARGS__"))->setIsPoisoned(); (Ident__VA_ARGS__ = getIdentifierInfo("__VA_ARGS__"))->setIsPoisoned();
SetPoisonReason(Ident__VA_ARGS__,diag::ext_pp_bad_vaargs_use); SetPoisonReason(Ident__VA_ARGS__,diag::ext_pp_bad_vaargs_use);
if (getLangOpts().CPlusPlus2a) { if (getLangOpts().CPlusPlus20) {
(Ident__VA_OPT__ = getIdentifierInfo("__VA_OPT__"))->setIsPoisoned(); (Ident__VA_OPT__ = getIdentifierInfo("__VA_OPT__"))->setIsPoisoned();
SetPoisonReason(Ident__VA_OPT__,diag::ext_pp_bad_vaopt_use); SetPoisonReason(Ident__VA_OPT__,diag::ext_pp_bad_vaopt_use);
} else { } else {
Ident__VA_OPT__ = nullptr; Ident__VA_OPT__ = nullptr;
} }
// Initialize the pragma handlers. // Initialize the pragma handlers.
RegisterBuiltinPragmas(); RegisterBuiltinPragmas();
▲ Show 20 Lines • Show All 635 Lines • ▼ Show 20 Lines
static diag::kind getFutureCompatDiagKind(const IdentifierInfo &II, static diag::kind getFutureCompatDiagKind(const IdentifierInfo &II,
const LangOptions &LangOpts) { const LangOptions &LangOpts) {
assert(II.isFutureCompatKeyword() && "diagnostic should not be needed"); assert(II.isFutureCompatKeyword() && "diagnostic should not be needed");
if (LangOpts.CPlusPlus) if (LangOpts.CPlusPlus)
return llvm::StringSwitch<diag::kind>(II.getName()) return llvm::StringSwitch<diag::kind>(II.getName())
#define CXX11_KEYWORD(NAME, FLAGS) \ #define CXX11_KEYWORD(NAME, FLAGS) \
.Case(#NAME, diag::warn_cxx11_keyword) .Case(#NAME, diag::warn_cxx11_keyword)
#define CXX2A_KEYWORD(NAME, FLAGS) \ #define CXX20_KEYWORD(NAME, FLAGS) \
.Case(#NAME, diag::warn_cxx2a_keyword) .Case(#NAME, diag::warn_cxx2a_keyword)
#include "clang/Basic/TokenKinds.def" #include "clang/Basic/TokenKinds.def"
; ;
llvm_unreachable( llvm_unreachable(
"Keyword not known to come from a newer Standard or proposed Standard"); "Keyword not known to come from a newer Standard or proposed Standard");
} }
▲ Show 20 Lines • Show All 638 Lines • Show Last 20 Lines

clang/lib/Lex/TokenConcatenation.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines if (PP.getLangOpts().CPlusPlus11) {
TokenInfo[tok::utf32_char_constant ] |= aci_custom; TokenInfo[tok::utf32_char_constant ] |= aci_custom;
} }
// These tokens have custom code in C++17 mode. // These tokens have custom code in C++17 mode.
if (PP.getLangOpts().CPlusPlus17) if (PP.getLangOpts().CPlusPlus17)
TokenInfo[tok::utf8_char_constant] |= aci_custom; TokenInfo[tok::utf8_char_constant] |= aci_custom;
// These tokens have custom code in C++2a mode. // These tokens have custom code in C++2a mode.
if (PP.getLangOpts().CPlusPlus2a) if (PP.getLangOpts().CPlusPlus20)
TokenInfo[tok::lessequal ] |= aci_custom_firstchar; TokenInfo[tok::lessequal ] |= aci_custom_firstchar;
// These tokens change behavior if followed by an '='. // These tokens change behavior if followed by an '='.
TokenInfo[tok::amp ] |= aci_avoid_equal; // &= TokenInfo[tok::amp ] |= aci_avoid_equal; // &=
TokenInfo[tok::plus ] |= aci_avoid_equal; // += TokenInfo[tok::plus ] |= aci_avoid_equal; // +=
TokenInfo[tok::minus ] |= aci_avoid_equal; // -= TokenInfo[tok::minus ] |= aci_avoid_equal; // -=
TokenInfo[tok::slash ] |= aci_avoid_equal; // /= TokenInfo[tok::slash ] |= aci_avoid_equal; // /=
TokenInfo[tok::less ] |= aci_avoid_equal; // <= TokenInfo[tok::less ] |= aci_avoid_equal; // <=
▲ Show 20 Lines • Show All 172 Lines • ▼ Show 20 Linesbool TokenConcatenation::AvoidConcat(const Token &PrevPrevTok,
case tok::colon: // ::, :> case tok::colon: // ::, :>
return FirstChar == '>' || return FirstChar == '>' ||
(PP.getLangOpts().CPlusPlus && FirstChar == ':'); (PP.getLangOpts().CPlusPlus && FirstChar == ':');
case tok::hash: // ##, #@, %:%: case tok::hash: // ##, #@, %:%:
return FirstChar == '#' || FirstChar == '@' || FirstChar == '%'; return FirstChar == '#' || FirstChar == '@' || FirstChar == '%';
case tok::arrow: // ->* case tok::arrow: // ->*
return PP.getLangOpts().CPlusPlus && FirstChar == '*'; return PP.getLangOpts().CPlusPlus && FirstChar == '*';
case tok::lessequal: // <=> (C++2a) case tok::lessequal: // <=> (C++2a)
return PP.getLangOpts().CPlusPlus2a && FirstChar == '>'; return PP.getLangOpts().CPlusPlus20 && FirstChar == '>';
} }
} }

clang/lib/Parse/ParseDecl.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
else else
Diag(ConsumeToken(), diag::err_deleted_non_function); Diag(ConsumeToken(), diag::err_deleted_non_function);
} else if (Tok.is(tok::kw_default)) { } else if (Tok.is(tok::kw_default)) {
if (D.isFunctionDeclarator()) if (D.isFunctionDeclarator())
Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration) Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
<< 0 /* default */; << 0 /* default */;
else else
Diag(ConsumeToken(), diag::err_default_special_members) Diag(ConsumeToken(), diag::err_default_special_members)
<< getLangOpts().CPlusPlus2a; << getLangOpts().CPlusPlus20;
} else { } else {
InitializerScopeRAII InitScope(*this, D, ThisDecl); InitializerScopeRAII InitScope(*this, D, ThisDecl);
if (Tok.is(tok::code_completion)) { if (Tok.is(tok::code_completion)) {
Actions.CodeCompleteInitializer(getCurScope(), ThisDecl); Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
Actions.FinalizeDeclaration(ThisDecl); Actions.FinalizeDeclaration(ThisDecl);
cutOffParsing(); cutOffParsing();
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 1,336 Lines • ▼ Show 20 Lines
break; break;
case tok::kw_explicit: { case tok::kw_explicit: {
SourceLocation ExplicitLoc = Loc; SourceLocation ExplicitLoc = Loc;
SourceLocation CloseParenLoc; SourceLocation CloseParenLoc;
ExplicitSpecifier ExplicitSpec(nullptr, ExplicitSpecKind::ResolvedTrue); ExplicitSpecifier ExplicitSpec(nullptr, ExplicitSpecKind::ResolvedTrue);
ConsumedEnd = ExplicitLoc; ConsumedEnd = ExplicitLoc;
ConsumeToken(); // kw_explicit ConsumeToken(); // kw_explicit
if (Tok.is(tok::l_paren)) { if (Tok.is(tok::l_paren)) {
if (getLangOpts().CPlusPlus2a || isExplicitBool() == TPResult::True) { if (getLangOpts().CPlusPlus20 || isExplicitBool() == TPResult::True) {
Diag(Tok.getLocation(), getLangOpts().CPlusPlus2a Diag(Tok.getLocation(), getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_explicit_bool ? diag::warn_cxx17_compat_explicit_bool
: diag::ext_explicit_bool); : diag::ext_explicit_bool);
ExprResult ExplicitExpr(static_cast<Expr *>(nullptr)); ExprResult ExplicitExpr(static_cast<Expr *>(nullptr));
BalancedDelimiterTracker Tracker(*this, tok::l_paren); BalancedDelimiterTracker Tracker(*this, tok::l_paren);
Tracker.consumeOpen(); Tracker.consumeOpen();
ExplicitExpr = ParseConstantExpression(); ExplicitExpr = ParseConstantExpression();
ConsumedEnd = Tok.getLocation(); ConsumedEnd = Tok.getLocation();
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Parse/ParseDeclCXX.cpp

Show First 20 Lines • Show All 149 Lines • ▼ Show 20 Lines
SkipUntil(tok::r_brace); SkipUntil(tok::r_brace);
return nullptr; return nullptr;
} }
if (ExtraNSs.empty()) { if (ExtraNSs.empty()) {
// Normal namespace definition, not a nested-namespace-definition. // Normal namespace definition, not a nested-namespace-definition.
} else if (InlineLoc.isValid()) { } else if (InlineLoc.isValid()) {
Diag(InlineLoc, diag::err_inline_nested_namespace_definition); Diag(InlineLoc, diag::err_inline_nested_namespace_definition);
} else if (getLangOpts().CPlusPlus2a) { } else if (getLangOpts().CPlusPlus20) {
Diag(ExtraNSs[0].NamespaceLoc, Diag(ExtraNSs[0].NamespaceLoc,
diag::warn_cxx14_compat_nested_namespace_definition); diag::warn_cxx14_compat_nested_namespace_definition);
if (FirstNestedInlineLoc.isValid()) if (FirstNestedInlineLoc.isValid())
Diag(FirstNestedInlineLoc, Diag(FirstNestedInlineLoc,
diag::warn_cxx17_compat_inline_nested_namespace_definition); diag::warn_cxx17_compat_inline_nested_namespace_definition);
} else if (getLangOpts().CPlusPlus17) { } else if (getLangOpts().CPlusPlus17) {
Diag(ExtraNSs[0].NamespaceLoc, Diag(ExtraNSs[0].NamespaceLoc,
diag::warn_cxx14_compat_nested_namespace_definition); diag::warn_cxx14_compat_nested_namespace_definition);
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
HasStaticInitializer = true; HasStaticInitializer = true;
} else if (DeclaratorInfo.getDeclSpec().getStorageClassSpec() != } else if (DeclaratorInfo.getDeclSpec().getStorageClassSpec() !=
DeclSpec::SCS_static && DeclSpec::SCS_static &&
DeclaratorInfo.getDeclSpec().getStorageClassSpec() != DeclaratorInfo.getDeclSpec().getStorageClassSpec() !=
DeclSpec::SCS_typedef && DeclSpec::SCS_typedef &&
!DS.isFriendSpecified()) { !DS.isFriendSpecified()) {
// It's a default member initializer. // It's a default member initializer.
if (BitfieldSize.get()) if (BitfieldSize.get())
Diag(Tok, getLangOpts().CPlusPlus2a Diag(Tok, getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_bitfield_member_init ? diag::warn_cxx17_compat_bitfield_member_init
: diag::ext_bitfield_member_init); : diag::ext_bitfield_member_init);
HasInClassInit = Tok.is(tok::equal) ? ICIS_CopyInit : ICIS_ListInit; HasInClassInit = Tok.is(tok::equal) ? ICIS_CopyInit : ICIS_ListInit;
} else { } else {
HasStaticInitializer = true; HasStaticInitializer = true;
} }
} }
▲ Show 20 Lines • Show All 188 Lines • ▼ Show 20 Lines
return ExprError(); return ExprError();
} }
} else if (Tok.is(tok::kw_default)) { } else if (Tok.is(tok::kw_default)) {
if (IsFunction) if (IsFunction)
Diag(Tok, diag::err_default_delete_in_multiple_declaration) Diag(Tok, diag::err_default_delete_in_multiple_declaration)
<< 0 /* default */; << 0 /* default */;
else else
Diag(ConsumeToken(), diag::err_default_special_members) Diag(ConsumeToken(), diag::err_default_special_members)
<< getLangOpts().CPlusPlus2a; << getLangOpts().CPlusPlus20;
return ExprError(); return ExprError();
} }
} }
if (const auto *PD = dyn_cast_or_null<MSPropertyDecl>(D)) { if (const auto *PD = dyn_cast_or_null<MSPropertyDecl>(D)) {
Diag(Tok, diag::err_ms_property_initializer) << PD; Diag(Tok, diag::err_ms_property_initializer) << PD;
return ExprError(); return ExprError();
} }
return ParseInitializer(); return ParseInitializer();
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Parse/ParseExprCXX.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
<< A.getAttrName()->getName(); << A.getAttrName()->getName();
}; };
// FIXME: Consider allowing this as an extension for GCC compatibiblity. // FIXME: Consider allowing this as an extension for GCC compatibiblity.
const bool HasExplicitTemplateParams = Tok.is(tok::less); const bool HasExplicitTemplateParams = Tok.is(tok::less);
ParseScope TemplateParamScope(this, Scope::TemplateParamScope, ParseScope TemplateParamScope(this, Scope::TemplateParamScope,
/*EnteredScope=*/HasExplicitTemplateParams); /*EnteredScope=*/HasExplicitTemplateParams);
if (HasExplicitTemplateParams) { if (HasExplicitTemplateParams) {
Diag(Tok, getLangOpts().CPlusPlus2a Diag(Tok, getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_lambda_template_parameter_list ? diag::warn_cxx17_compat_lambda_template_parameter_list
: diag::ext_lambda_template_parameter_list); : diag::ext_lambda_template_parameter_list);
SmallVector<NamedDecl*, 4> TemplateParams; SmallVector<NamedDecl*, 4> TemplateParams;
SourceLocation LAngleLoc, RAngleLoc; SourceLocation LAngleLoc, RAngleLoc;
if (ParseTemplateParameters(CurTemplateDepthTracker.getDepth(), if (ParseTemplateParameters(CurTemplateDepthTracker.getDepth(),
TemplateParams, LAngleLoc, RAngleLoc)) { TemplateParams, LAngleLoc, RAngleLoc)) {
Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope()); Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Parse/ParseStmt.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
ColonProtectionRAIIObject ColonProtection(*this, MightBeForRangeStmt); ColonProtectionRAIIObject ColonProtection(*this, MightBeForRangeStmt);
SecondPart = SecondPart =
ParseCXXCondition(nullptr, ForLoc, Sema::ConditionKind::Boolean, ParseCXXCondition(nullptr, ForLoc, Sema::ConditionKind::Boolean,
MightBeForRangeStmt ? &ForRangeInfo : nullptr); MightBeForRangeStmt ? &ForRangeInfo : nullptr);
if (ForRangeInfo.ParsedForRangeDecl()) { if (ForRangeInfo.ParsedForRangeDecl()) {
Diag(FirstPart.get() ? FirstPart.get()->getBeginLoc() Diag(FirstPart.get() ? FirstPart.get()->getBeginLoc()
: ForRangeInfo.ColonLoc, : ForRangeInfo.ColonLoc,
getLangOpts().CPlusPlus2a getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_for_range_init_stmt ? diag::warn_cxx17_compat_for_range_init_stmt
: diag::ext_for_range_init_stmt) : diag::ext_for_range_init_stmt)
<< (FirstPart.get() ? FirstPart.get()->getSourceRange() << (FirstPart.get() ? FirstPart.get()->getSourceRange()
: SourceRange()); : SourceRange());
if (EmptyInitStmtSemiLoc.isValid()) { if (EmptyInitStmtSemiLoc.isValid()) {
Diag(EmptyInitStmtSemiLoc, diag::warn_empty_init_statement) Diag(EmptyInitStmtSemiLoc, diag::warn_empty_init_statement)
<< /*for-loop*/ 2 << /*for-loop*/ 2
<< FixItHint::CreateRemoval(EmptyInitStmtSemiLoc); << FixItHint::CreateRemoval(EmptyInitStmtSemiLoc);
▲ Show 20 Lines • Show All 578 Lines • Show Last 20 Lines

clang/lib/Parse/ParseTemplate.cpp

Show First 20 Lines • Show All 674 Lines • ▼ Show 20 Lines
/// ///
/// type-constraint: /// type-constraint:
/// nested-name-specifier[opt] concept-name /// nested-name-specifier[opt] concept-name
/// nested-name-specifier[opt] concept-name /// nested-name-specifier[opt] concept-name
/// '<' template-argument-list[opt] '>'[opt] /// '<' template-argument-list[opt] '>'[opt]
/// ///
/// \returns true if an error occurred, and false otherwise. /// \returns true if an error occurred, and false otherwise.
bool Parser::TryAnnotateTypeConstraint() { bool Parser::TryAnnotateTypeConstraint() {
if (!getLangOpts().CPlusPlus2a) if (!getLangOpts().CPlusPlus20)
return false; return false;
CXXScopeSpec SS; CXXScopeSpec SS;
bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope); bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope);
if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr, if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
/*ObjectHadErrors=*/false, /*ObjectHadErrors=*/false,
/*EnteringContext=*/false, /*EnteringContext=*/false,
/*MayBePseudoDestructor=*/nullptr, /*MayBePseudoDestructor=*/nullptr,
// If this is not a type-constraint, then // If this is not a type-constraint, then
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Sema/SemaDecl.cpp

Show First 20 Lines • Show All 920 Lines • ▼ Show 20 Lines
// //
// appeared. // appeared.
// //
// We also allow this in C99 as an extension. // We also allow this in C99 as an extension.
if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S))
return NameClassification::NonType(D); return NameClassification::NonType(D);
} }
if (getLangOpts().CPlusPlus2a && SS.isEmpty() && NextToken.is(tok::less)) { if (getLangOpts().CPlusPlus20 && SS.isEmpty() && NextToken.is(tok::less)) {
// In C++20 onwards, this could be an ADL-only call to a function // In C++20 onwards, this could be an ADL-only call to a function
// template, and we're required to assume that this is a template name. // template, and we're required to assume that this is a template name.
// //
// FIXME: Find a way to still do typo correction in this case. // FIXME: Find a way to still do typo correction in this case.
TemplateName Template = TemplateName Template =
Context.getAssumedTemplateName(NameInfo.getName()); Context.getAssumedTemplateName(NameInfo.getName());
return NameClassification::UndeclaredTemplate(Template); return NameClassification::UndeclaredTemplate(Template);
} }
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines
} }
if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
(IsFilteredTemplateName || (IsFilteredTemplateName ||
hasAnyAcceptableTemplateNames( hasAnyAcceptableTemplateNames(
Result, /*AllowFunctionTemplates=*/true, Result, /*AllowFunctionTemplates=*/true,
/*AllowDependent=*/false, /*AllowDependent=*/false,
/*AllowNonTemplateFunctions*/ SS.isEmpty() && /*AllowNonTemplateFunctions*/ SS.isEmpty() &&
getLangOpts().CPlusPlus2a))) { getLangOpts().CPlusPlus20))) {
// C++ [temp.names]p3: // C++ [temp.names]p3:
// After name lookup (3.4) finds that a name is a template-name or that // After name lookup (3.4) finds that a name is a template-name or that
// an operator-function-id or a literal- operator-id refers to a set of // an operator-function-id or a literal- operator-id refers to a set of
// overloaded functions any member of which is a function template if // overloaded functions any member of which is a function template if
// this is followed by a <, the < is always taken as the delimiter of a // this is followed by a <, the < is always taken as the delimiter of a
// template-argument-list and never as the less-than operator. // template-argument-list and never as the less-than operator.
// C++2a [temp.names]p2: // C++2a [temp.names]p2:
// A name is also considered to refer to a template if it is an // A name is also considered to refer to a template if it is an
▲ Show 20 Lines • Show All 1,673 Lines • ▼ Show 20 Lines
bool AttrBeforeInit) { bool AttrBeforeInit) {
SourceLocation InsertLoc = InitDecl->getInnerLocStart(); SourceLocation InsertLoc = InitDecl->getInnerLocStart();
// Figure out a good way to write this specifier on the old declaration. // Figure out a good way to write this specifier on the old declaration.
// FIXME: We should just use the spelling of CIAttr, but we don't preserve // FIXME: We should just use the spelling of CIAttr, but we don't preserve
// enough of the attribute list spelling information to extract that without // enough of the attribute list spelling information to extract that without
// heroics. // heroics.
std::string SuitableSpelling; std::string SuitableSpelling;
if (S.getLangOpts().CPlusPlus2a) if (S.getLangOpts().CPlusPlus20)
SuitableSpelling = std::string( SuitableSpelling = std::string(
S.PP.getLastMacroWithSpelling(InsertLoc, {tok::kw_constinit})); S.PP.getLastMacroWithSpelling(InsertLoc, {tok::kw_constinit}));
if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus11) if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus11)
SuitableSpelling = std::string(S.PP.getLastMacroWithSpelling( SuitableSpelling = std::string(S.PP.getLastMacroWithSpelling(
InsertLoc, {tok::l_square, tok::l_square, InsertLoc, {tok::l_square, tok::l_square,
S.PP.getIdentifierInfo("clang"), tok::coloncolon, S.PP.getIdentifierInfo("clang"), tok::coloncolon,
S.PP.getIdentifierInfo("require_constant_initialization"), S.PP.getIdentifierInfo("require_constant_initialization"),
tok::r_square, tok::r_square})); tok::r_square, tok::r_square}));
if (SuitableSpelling.empty()) if (SuitableSpelling.empty())
SuitableSpelling = std::string(S.PP.getLastMacroWithSpelling( SuitableSpelling = std::string(S.PP.getLastMacroWithSpelling(
InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren, InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren,
S.PP.getIdentifierInfo("require_constant_initialization"), S.PP.getIdentifierInfo("require_constant_initialization"),
tok::r_paren, tok::r_paren})); tok::r_paren, tok::r_paren}));
if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus2a) if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus20)
SuitableSpelling = "constinit"; SuitableSpelling = "constinit";
if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus11) if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus11)
SuitableSpelling = "[[clang::require_constant_initialization]]"; SuitableSpelling = "[[clang::require_constant_initialization]]";
if (SuitableSpelling.empty()) if (SuitableSpelling.empty())
SuitableSpelling = "__attribute__((require_constant_initialization))"; SuitableSpelling = "__attribute__((require_constant_initialization))";
SuitableSpelling += " "; SuitableSpelling += " ";
if (AttrBeforeInit) { if (AttrBeforeInit) {
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
// C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
// are implicitly inline. // are implicitly inline.
NewFD->setImplicitlyInline(); NewFD->setImplicitlyInline();
// C++11 [dcl.constexpr]p3: functions declared constexpr are required to // C++11 [dcl.constexpr]p3: functions declared constexpr are required to
// be either constructors or to return a literal type. Therefore, // be either constructors or to return a literal type. Therefore,
// destructors cannot be declared constexpr. // destructors cannot be declared constexpr.
if (isa<CXXDestructorDecl>(NewFD) && if (isa<CXXDestructorDecl>(NewFD) &&
(!getLangOpts().CPlusPlus2a || ConstexprKind == CSK_consteval)) { (!getLangOpts().CPlusPlus20 || ConstexprKind == CSK_consteval)) {
Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor) Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor)
<< ConstexprKind; << ConstexprKind;
NewFD->setConstexprKind(getLangOpts().CPlusPlus2a ? CSK_unspecified : CSK_constexpr); NewFD->setConstexprKind(getLangOpts().CPlusPlus20 ? CSK_unspecified : CSK_constexpr);
} }
// C++20 [dcl.constexpr]p2: An allocation function, or a // C++20 [dcl.constexpr]p2: An allocation function, or a
// deallocation function shall not be declared with the consteval // deallocation function shall not be declared with the consteval
// specifier. // specifier.
if (ConstexprKind == CSK_consteval && if (ConstexprKind == CSK_consteval &&
(NewFD->getOverloadedOperator() == OO_New || (NewFD->getOverloadedOperator() == OO_New ||
NewFD->getOverloadedOperator() == OO_Array_New || NewFD->getOverloadedOperator() == OO_Array_New ||
NewFD->getOverloadedOperator() == OO_Delete || NewFD->getOverloadedOperator() == OO_Delete ||
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Sema/SemaDeclAttr.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
// If this is spelled as the standard C++17 attribute, but not in C++17, // If this is spelled as the standard C++17 attribute, but not in C++17,
// warn about using it as an extension. If there are attribute arguments, // warn about using it as an extension. If there are attribute arguments,
// then claim it's a C++2a extension instead. // then claim it's a C++2a extension instead.
// FIXME: If WG14 does not seem likely to adopt the same feature, add an // FIXME: If WG14 does not seem likely to adopt the same feature, add an
// extension warning for C2x mode. // extension warning for C2x mode.
const LangOptions &LO = S.getLangOpts(); const LangOptions &LO = S.getLangOpts();
if (AL.getNumArgs() == 1) { if (AL.getNumArgs() == 1) {
if (LO.CPlusPlus && !LO.CPlusPlus2a) if (LO.CPlusPlus && !LO.CPlusPlus20)
S.Diag(AL.getLoc(), diag::ext_cxx2a_attr) << AL; S.Diag(AL.getLoc(), diag::ext_cxx2a_attr) << AL;
// Since this this is spelled [[nodiscard]], get the optional string // Since this this is spelled [[nodiscard]], get the optional string
// literal. If in C++ mode, but not in C++2a mode, diagnose as an // literal. If in C++ mode, but not in C++2a mode, diagnose as an
// extension. // extension.
// FIXME: C2x should support this feature as well, even as an extension. // FIXME: C2x should support this feature as well, even as an extension.
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, nullptr)) if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, nullptr))
return; return;
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Sema/SemaDeclCXX.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 755 Lines • ▼ Show 20 Lines
Err << (int)BadSpecifiers.size() Err << (int)BadSpecifiers.size()
<< llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(), " "); << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(), " ");
// Don't add FixItHints to remove the specifiers; we do still respect // Don't add FixItHints to remove the specifiers; we do still respect
// them when building the underlying variable. // them when building the underlying variable.
for (auto Loc : BadSpecifierLocs) for (auto Loc : BadSpecifierLocs)
Err << SourceRange(Loc, Loc); Err << SourceRange(Loc, Loc);
} else if (!CPlusPlus20Specifiers.empty()) { } else if (!CPlusPlus20Specifiers.empty()) {
auto &&Warn = Diag(CPlusPlus20SpecifierLocs.front(), auto &&Warn = Diag(CPlusPlus20SpecifierLocs.front(),
getLangOpts().CPlusPlus2a getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_decomp_decl_spec ? diag::warn_cxx17_compat_decomp_decl_spec
: diag::ext_decomp_decl_spec); : diag::ext_decomp_decl_spec);
Warn << (int)CPlusPlus20Specifiers.size() Warn << (int)CPlusPlus20Specifiers.size()
<< llvm::join(CPlusPlus20Specifiers.begin(), << llvm::join(CPlusPlus20Specifiers.begin(),
CPlusPlus20Specifiers.end(), " "); CPlusPlus20Specifiers.end(), " ");
for (auto Loc : CPlusPlus20SpecifierLocs) for (auto Loc : CPlusPlus20SpecifierLocs)
Warn << SourceRange(Loc, Loc); Warn << SourceRange(Loc, Loc);
} }
// We can't recover from it being declared as a typedef. // We can't recover from it being declared as a typedef.
if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
return nullptr; return nullptr;
} }
// C++2a [dcl.struct.bind]p1: // C++2a [dcl.struct.bind]p1:
// A cv that includes volatile is deprecated // A cv that includes volatile is deprecated
if ((DS.getTypeQualifiers() & DeclSpec::TQ_volatile) && if ((DS.getTypeQualifiers() & DeclSpec::TQ_volatile) &&
getLangOpts().CPlusPlus2a) getLangOpts().CPlusPlus20)
Diag(DS.getVolatileSpecLoc(), Diag(DS.getVolatileSpecLoc(),
diag::warn_deprecated_volatile_structured_binding); diag::warn_deprecated_volatile_structured_binding);
TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
QualType R = TInfo->getType(); QualType R = TInfo->getType();
if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
UPPC_DeclarationType)) UPPC_DeclarationType))
▲ Show 20 Lines • Show All 921 Lines • ▼ Show 20 Lines
if (!isa<CXXConstructorDecl>(NewFD)) { if (!isa<CXXConstructorDecl>(NewFD)) {
// C++11 [dcl.constexpr]p3: // C++11 [dcl.constexpr]p3:
// The definition of a constexpr function shall satisfy the following // The definition of a constexpr function shall satisfy the following
// constraints: // constraints:
// - it shall not be virtual; (removed in C++20) // - it shall not be virtual; (removed in C++20)
const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD); const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
if (Method && Method->isVirtual()) { if (Method && Method->isVirtual()) {
if (getLangOpts().CPlusPlus2a) { if (getLangOpts().CPlusPlus20) {
if (Kind == CheckConstexprKind::Diagnose) if (Kind == CheckConstexprKind::Diagnose)
Diag(Method->getLocation(), diag::warn_cxx17_compat_constexpr_virtual); Diag(Method->getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
} else { } else {
if (Kind == CheckConstexprKind::CheckValid) if (Kind == CheckConstexprKind::CheckValid)
return false; return false;
Method = Method->getCanonicalDecl(); Method = Method->getCanonicalDecl();
Diag(Method->getLocation(), diag::err_constexpr_virtual); Diag(Method->getLocation(), diag::err_constexpr_virtual);
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines
diag::err_constexpr_local_var_non_literal_type, diag::err_constexpr_local_var_non_literal_type,
isa<CXXConstructorDecl>(Dcl))) isa<CXXConstructorDecl>(Dcl)))
return false; return false;
if (!VD->getType()->isDependentType() && if (!VD->getType()->isDependentType() &&
!VD->hasInit() && !VD->isCXXForRangeDecl()) { !VD->hasInit() && !VD->isCXXForRangeDecl()) {
if (Kind == Sema::CheckConstexprKind::Diagnose) { if (Kind == Sema::CheckConstexprKind::Diagnose) {
SemaRef.Diag( SemaRef.Diag(
VD->getLocation(), VD->getLocation(),
SemaRef.getLangOpts().CPlusPlus2a SemaRef.getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_constexpr_local_var_no_init ? diag::warn_cxx17_compat_constexpr_local_var_no_init
: diag::ext_constexpr_local_var_no_init) : diag::ext_constexpr_local_var_no_init)
<< isa<CXXConstructorDecl>(Dcl); << isa<CXXConstructorDecl>(Dcl);
} else if (!SemaRef.getLangOpts().CPlusPlus2a) { } else if (!SemaRef.getLangOpts().CPlusPlus20) {
return false; return false;
} }
continue; continue;
} }
} }
if (Kind == Sema::CheckConstexprKind::Diagnose) { if (Kind == Sema::CheckConstexprKind::Diagnose) {
SemaRef.Diag(VD->getLocation(), SemaRef.Diag(VD->getLocation(),
SemaRef.getLangOpts().CPlusPlus14 SemaRef.getLangOpts().CPlusPlus14
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
static bool CheckConstexprCtorInitializer(Sema &SemaRef, static bool CheckConstexprCtorInitializer(Sema &SemaRef,
const FunctionDecl *Dcl, const FunctionDecl *Dcl,
FieldDecl *Field, FieldDecl *Field,
llvm::SmallSet<Decl*, 16> &Inits, llvm::SmallSet<Decl*, 16> &Inits,
bool &Diagnosed, bool &Diagnosed,
Sema::CheckConstexprKind Kind) { Sema::CheckConstexprKind Kind) {
// In C++20 onwards, there's nothing to check for validity. // In C++20 onwards, there's nothing to check for validity.
if (Kind == Sema::CheckConstexprKind::CheckValid && if (Kind == Sema::CheckConstexprKind::CheckValid &&
SemaRef.getLangOpts().CPlusPlus2a) SemaRef.getLangOpts().CPlusPlus20)
return true; return true;
if (Field->isInvalidDecl()) if (Field->isInvalidDecl())
return true; return true;
if (Field->isUnnamedBitfield()) if (Field->isUnnamedBitfield())
return true; return true;
// Anonymous unions with no variant members and empty anonymous structs do not // Anonymous unions with no variant members and empty anonymous structs do not
// need to be explicitly initialized. FIXME: Anonymous structs that contain no // need to be explicitly initialized. FIXME: Anonymous structs that contain no
// indirect fields don't need initializing. // indirect fields don't need initializing.
if (Field->isAnonymousStructOrUnion() && if (Field->isAnonymousStructOrUnion() &&
(Field->getType()->isUnionType() (Field->getType()->isUnionType()
? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers() ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
: Field->getType()->getAsCXXRecordDecl()->isEmpty())) : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
return true; return true;
if (!Inits.count(Field)) { if (!Inits.count(Field)) {
if (Kind == Sema::CheckConstexprKind::Diagnose) { if (Kind == Sema::CheckConstexprKind::Diagnose) {
if (!Diagnosed) { if (!Diagnosed) {
SemaRef.Diag(Dcl->getLocation(), SemaRef.Diag(Dcl->getLocation(),
SemaRef.getLangOpts().CPlusPlus2a SemaRef.getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_constexpr_ctor_missing_init ? diag::warn_cxx17_compat_constexpr_ctor_missing_init
: diag::ext_constexpr_ctor_missing_init); : diag::ext_constexpr_ctor_missing_init);
Diagnosed = true; Diagnosed = true;
} }
SemaRef.Diag(Field->getLocation(), SemaRef.Diag(Field->getLocation(),
diag::note_constexpr_ctor_missing_init); diag::note_constexpr_ctor_missing_init);
} else if (!SemaRef.getLangOpts().CPlusPlus2a) { } else if (!SemaRef.getLangOpts().CPlusPlus20) {
return false; return false;
} }
} else if (Field->isAnonymousStructOrUnion()) { } else if (Field->isAnonymousStructOrUnion()) {
const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl(); const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
for (auto *I : RD->fields()) for (auto *I : RD->fields())
// If an anonymous union contains an anonymous struct of which any member // If an anonymous union contains an anonymous struct of which any member
// is initialized, all members must be initialized. // is initialized, all members must be initialized.
if (!RD->isUnion() || Inits.count(I)) if (!RD->isUnion() || Inits.count(I))
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Lines
// C++11 [dcl.constexpr]p4: // C++11 [dcl.constexpr]p4:
// In the definition of a constexpr constructor, [...] // In the definition of a constexpr constructor, [...]
// - its function-body shall not be a function-try-block; // - its function-body shall not be a function-try-block;
// //
// This restriction is lifted in C++2a, as long as inner statements also // This restriction is lifted in C++2a, as long as inner statements also
// apply the general constexpr rules. // apply the general constexpr rules.
switch (Kind) { switch (Kind) {
case Sema::CheckConstexprKind::CheckValid: case Sema::CheckConstexprKind::CheckValid:
if (!SemaRef.getLangOpts().CPlusPlus2a) if (!SemaRef.getLangOpts().CPlusPlus20)
return false; return false;
break; break;
case Sema::CheckConstexprKind::Diagnose: case Sema::CheckConstexprKind::Diagnose:
SemaRef.Diag(Body->getBeginLoc(), SemaRef.Diag(Body->getBeginLoc(),
!SemaRef.getLangOpts().CPlusPlus2a !SemaRef.getLangOpts().CPlusPlus20
? diag::ext_constexpr_function_try_block_cxx2a ? diag::ext_constexpr_function_try_block_cxx2a
: diag::warn_cxx17_compat_constexpr_function_try_block) : diag::warn_cxx17_compat_constexpr_function_try_block)
<< isa<CXXConstructorDecl>(Dcl); << isa<CXXConstructorDecl>(Dcl);
break; break;
} }
} }
// - its function-body shall be [...] a compound-statement that contains only // - its function-body shall be [...] a compound-statement that contains only
// [... list of cases ...] // [... list of cases ...]
// //
// Note that walking the children here is enough to properly check for // Note that walking the children here is enough to properly check for
// CompoundStmt and CXXTryStmt body. // CompoundStmt and CXXTryStmt body.
SourceLocation Cxx1yLoc, Cxx2aLoc; SourceLocation Cxx1yLoc, Cxx2aLoc;
for (Stmt *SubStmt : Body->children()) { for (Stmt *SubStmt : Body->children()) {
if (SubStmt && if (SubStmt &&
!CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts, !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
Cxx1yLoc, Cxx2aLoc, Kind)) Cxx1yLoc, Cxx2aLoc, Kind))
return false; return false;
} }
if (Kind == Sema::CheckConstexprKind::CheckValid) { if (Kind == Sema::CheckConstexprKind::CheckValid) {
// If this is only valid as an extension, report that we don't satisfy the // If this is only valid as an extension, report that we don't satisfy the
// constraints of the current language. // constraints of the current language.
if ((Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus2a) || if ((Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus20) ||
(Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17)) (Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17))
return false; return false;
} else if (Cxx2aLoc.isValid()) { } else if (Cxx2aLoc.isValid()) {
SemaRef.Diag(Cxx2aLoc, SemaRef.Diag(Cxx2aLoc,
SemaRef.getLangOpts().CPlusPlus2a SemaRef.getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_constexpr_body_invalid_stmt ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
: diag::ext_constexpr_body_invalid_stmt_cxx2a) : diag::ext_constexpr_body_invalid_stmt_cxx2a)
<< isa<CXXConstructorDecl>(Dcl); << isa<CXXConstructorDecl>(Dcl);
} else if (Cxx1yLoc.isValid()) { } else if (Cxx1yLoc.isValid()) {
SemaRef.Diag(Cxx1yLoc, SemaRef.Diag(Cxx1yLoc,
SemaRef.getLangOpts().CPlusPlus14 SemaRef.getLangOpts().CPlusPlus14
? diag::warn_cxx11_compat_constexpr_body_invalid_stmt ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
: diag::ext_constexpr_body_invalid_stmt) : diag::ext_constexpr_body_invalid_stmt)
Show All 10 Lines
// - if the class is a union having variant members, exactly one of them // - if the class is a union having variant members, exactly one of them
// shall be initialized; // shall be initialized;
if (RD->isUnion()) { if (RD->isUnion()) {
if (Constructor->getNumCtorInitializers() == 0 && if (Constructor->getNumCtorInitializers() == 0 &&
RD->hasVariantMembers()) { RD->hasVariantMembers()) {
if (Kind == Sema::CheckConstexprKind::Diagnose) { if (Kind == Sema::CheckConstexprKind::Diagnose) {
SemaRef.Diag( SemaRef.Diag(
Dcl->getLocation(), Dcl->getLocation(),
SemaRef.getLangOpts().CPlusPlus2a SemaRef.getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_constexpr_union_ctor_no_init ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init
: diag::ext_constexpr_union_ctor_no_init); : diag::ext_constexpr_union_ctor_no_init);
} else if (!SemaRef.getLangOpts().CPlusPlus2a) { } else if (!SemaRef.getLangOpts().CPlusPlus20) {
return false; return false;
} }
} }
} else if (!Constructor->isDependentContext() && } else if (!Constructor->isDependentContext() &&
!Constructor->isDelegatingConstructor()) { !Constructor->isDelegatingConstructor()) {
assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases"); assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
// Skip detailed checking if we have enough initializers, and we would // Skip detailed checking if we have enough initializers, and we would
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
case OO_EqualEqual: case OO_EqualEqual:
return DefaultedComparisonKind::Equal; return DefaultedComparisonKind::Equal;
case OO_ExclaimEqual: case OO_ExclaimEqual:
return DefaultedComparisonKind::NotEqual; return DefaultedComparisonKind::NotEqual;
case OO_Spaceship: case OO_Spaceship:
// No point allowing this if <=> doesn't exist in the current language mode. // No point allowing this if <=> doesn't exist in the current language mode.
if (!getLangOpts().CPlusPlus2a) if (!getLangOpts().CPlusPlus20)
break; break;
return DefaultedComparisonKind::ThreeWay; return DefaultedComparisonKind::ThreeWay;
case OO_Less: case OO_Less:
case OO_LessEqual: case OO_LessEqual:
case OO_Greater: case OO_Greater:
case OO_GreaterEqual: case OO_GreaterEqual:
// No point allowing this if <=> doesn't exist in the current language mode. // No point allowing this if <=> doesn't exist in the current language mode.
if (!getLangOpts().CPlusPlus2a) if (!getLangOpts().CPlusPlus20)
break; break;
return DefaultedComparisonKind::Relational; return DefaultedComparisonKind::Relational;
default: default:
break; break;
} }
// Not defaultable. // Not defaultable.
▲ Show 20 Lines • Show All 861 Lines • ▼ Show 20 Lines
// -- be a special member function [...] (checked elsewhere), // -- be a special member function [...] (checked elsewhere),
// -- have the same type (except for ref-qualifiers, and except that a // -- have the same type (except for ref-qualifiers, and except that a
// copy operation can take a non-const reference) as an implicit // copy operation can take a non-const reference) as an implicit
// declaration, and // declaration, and
// -- not have default arguments. // -- not have default arguments.
// C++2a changes the second bullet to instead delete the function if it's // C++2a changes the second bullet to instead delete the function if it's
// defaulted on its first declaration, unless it's "an assignment operator, // defaulted on its first declaration, unless it's "an assignment operator,
// and its return type differs or its parameter type is not a reference". // and its return type differs or its parameter type is not a reference".
bool DeleteOnTypeMismatch = getLangOpts().CPlusPlus2a && First; bool DeleteOnTypeMismatch = getLangOpts().CPlusPlus20 && First;
bool ShouldDeleteForTypeMismatch = false; bool ShouldDeleteForTypeMismatch = false;
unsigned ExpectedParams = 1; unsigned ExpectedParams = 1;
if (CSM == CXXDefaultConstructor || CSM == CXXDestructor) if (CSM == CXXDefaultConstructor || CSM == CXXDestructor)
ExpectedParams = 0; ExpectedParams = 0;
if (MD->getNumParams() != ExpectedParams) { if (MD->getNumParams() != ExpectedParams) {
// This checks for default arguments: a copy or move constructor with a // This checks for default arguments: a copy or move constructor with a
// default argument is classified as a default constructor, and assignment // default argument is classified as a default constructor, and assignment
// operations and destructors can't have default arguments. // operations and destructors can't have default arguments.
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
// Do not apply this rule to members of class templates, since core issue 1358 // Do not apply this rule to members of class templates, since core issue 1358
// makes such functions always instantiate to constexpr functions. For // makes such functions always instantiate to constexpr functions. For
// functions which cannot be constexpr (for non-constructors in C++11 and for // functions which cannot be constexpr (for non-constructors in C++11 and for
// destructors in C++14 and C++17), this is checked elsewhere. // destructors in C++14 and C++17), this is checked elsewhere.
// //
// FIXME: This should not apply if the member is deleted. // FIXME: This should not apply if the member is deleted.
bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM, bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
HasConstParam); HasConstParam);
if ((getLangOpts().CPlusPlus2a || if ((getLangOpts().CPlusPlus20 ||
(getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD) (getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
: isa<CXXConstructorDecl>(MD))) && : isa<CXXConstructorDecl>(MD))) &&
MD->isConstexpr() && !Constexpr && MD->isConstexpr() && !Constexpr &&
MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) { MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) {
Diag(MD->getBeginLoc(), MD->isConsteval() Diag(MD->getBeginLoc(), MD->isConsteval()
? diag::err_incorrect_defaulted_consteval ? diag::err_incorrect_defaulted_consteval
: diag::err_incorrect_defaulted_constexpr) : diag::err_incorrect_defaulted_constexpr)
<< CSM; << CSM;
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
} }
// C++2a [class.compare.default]p3: // C++2a [class.compare.default]p3:
// If the member-specification does not explicitly declare any member or // If the member-specification does not explicitly declare any member or
// friend named operator==, an == operator function is declared implicitly // friend named operator==, an == operator function is declared implicitly
// for each defaulted three-way comparison operator function defined in the // for each defaulted three-way comparison operator function defined in the
// member-specification // member-specification
// FIXME: Consider doing this lazily. // FIXME: Consider doing this lazily.
if (getLangOpts().CPlusPlus2a) { if (getLangOpts().CPlusPlus20) {
llvm::SmallVector<FunctionDecl*, 4> DefaultedSpaceships; llvm::SmallVector<FunctionDecl*, 4> DefaultedSpaceships;
findImplicitlyDeclaredEqualityComparisons(Context, ClassDecl, findImplicitlyDeclaredEqualityComparisons(Context, ClassDecl,
DefaultedSpaceships); DefaultedSpaceships);
for (auto *FD : DefaultedSpaceships) for (auto *FD : DefaultedSpaceships)
DeclareImplicitEqualityComparison(ClassDecl, FD); DeclareImplicitEqualityComparison(ClassDecl, FD);
} }
} }
▲ Show 20 Lines • Show All 583 Lines • ▼ Show 20 Lines
// Rebuild the function type "R" without any parameters (in case any // Rebuild the function type "R" without any parameters (in case any
// of the errors above fired) and with the conversion type as the // of the errors above fired) and with the conversion type as the
// return type. // return type.
if (D.isInvalidType()) if (D.isInvalidType())
R = Context.getFunctionType(ConvType, None, Proto->getExtProtoInfo()); R = Context.getFunctionType(ConvType, None, Proto->getExtProtoInfo());
// C++0x explicit conversion operators. // C++0x explicit conversion operators.
if (DS.hasExplicitSpecifier() && !getLangOpts().CPlusPlus2a) if (DS.hasExplicitSpecifier() && !getLangOpts().CPlusPlus20)
Diag(DS.getExplicitSpecLoc(), Diag(DS.getExplicitSpecLoc(),
getLangOpts().CPlusPlus11 getLangOpts().CPlusPlus11
? diag::warn_cxx98_compat_explicit_conversion_functions ? diag::warn_cxx98_compat_explicit_conversion_functions
: diag::ext_explicit_conversion_functions) : diag::ext_explicit_conversion_functions)
<< SourceRange(DS.getExplicitSpecRange()); << SourceRange(DS.getExplicitSpecRange());
} }
/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete /// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
if (auto *FTD = dyn_cast<FunctionTemplateDecl>(Dcl)) { if (auto *FTD = dyn_cast<FunctionTemplateDecl>(Dcl)) {
if (getDefaultedFunctionKind(FTD->getTemplatedDecl()).isComparison()) { if (getDefaultedFunctionKind(FTD->getTemplatedDecl()).isComparison()) {
Diag(DefaultLoc, diag::err_defaulted_comparison_template); Diag(DefaultLoc, diag::err_defaulted_comparison_template);
return; return;
} }
} }
Diag(DefaultLoc, diag::err_default_special_members) Diag(DefaultLoc, diag::err_default_special_members)
<< getLangOpts().CPlusPlus2a; << getLangOpts().CPlusPlus20;
return; return;
} }
// Reject if this can't possibly be a defaultable function. // Reject if this can't possibly be a defaultable function.
DefaultedFunctionKind DefKind = getDefaultedFunctionKind(FD); DefaultedFunctionKind DefKind = getDefaultedFunctionKind(FD);
if (!DefKind && if (!DefKind &&
// A dependent function that doesn't locally look defaultable can // A dependent function that doesn't locally look defaultable can
// still instantiate to a defaultable function if it's a constructor // still instantiate to a defaultable function if it's a constructor
// or assignment operator. // or assignment operator.
(!FD->isDependentContext() || (!FD->isDependentContext() ||
(!isa<CXXConstructorDecl>(FD) && (!isa<CXXConstructorDecl>(FD) &&
FD->getDeclName().getCXXOverloadedOperator() != OO_Equal))) { FD->getDeclName().getCXXOverloadedOperator() != OO_Equal))) {
Diag(DefaultLoc, diag::err_default_special_members) Diag(DefaultLoc, diag::err_default_special_members)
<< getLangOpts().CPlusPlus2a; << getLangOpts().CPlusPlus20;
return; return;
} }
if (DefKind.isComparison() && if (DefKind.isComparison() &&
!isa<CXXRecordDecl>(FD->getLexicalDeclContext())) { !isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
Diag(FD->getLocation(), diag::err_defaulted_comparison_out_of_class) Diag(FD->getLocation(), diag::err_defaulted_comparison_out_of_class)
<< (int)DefKind.asComparison(); << (int)DefKind.asComparison();
return; return;
} }
// Issue compatibility warning. We already warned if the operator is // Issue compatibility warning. We already warned if the operator is
// 'operator<=>' when parsing the '<=>' token. // 'operator<=>' when parsing the '<=>' token.
if (DefKind.isComparison() && if (DefKind.isComparison() &&
DefKind.asComparison() != DefaultedComparisonKind::ThreeWay) { DefKind.asComparison() != DefaultedComparisonKind::ThreeWay) {
Diag(DefaultLoc, getLangOpts().CPlusPlus2a Diag(DefaultLoc, getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_defaulted_comparison ? diag::warn_cxx17_compat_defaulted_comparison
: diag::ext_defaulted_comparison); : diag::ext_defaulted_comparison);
} }
FD->setDefaulted(); FD->setDefaulted();
FD->setExplicitlyDefaulted(); FD->setExplicitlyDefaulted();
// Defer checking functions that are defaulted in a dependent context. // Defer checking functions that are defaulted in a dependent context.
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Sema/SemaExpr.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
// Warn on this in all language modes. Produce a deprecation warning in C++20. // Warn on this in all language modes. Produce a deprecation warning in C++20.
// Eventually we will presumably reject these cases (in C++23 onwards?). // Eventually we will presumably reject these cases (in C++23 onwards?).
QualType L = LHS->getType(), R = RHS->getType(); QualType L = LHS->getType(), R = RHS->getType();
bool LEnum = L->isUnscopedEnumerationType(), bool LEnum = L->isUnscopedEnumerationType(),
REnum = R->isUnscopedEnumerationType(); REnum = R->isUnscopedEnumerationType();
bool IsCompAssign = ACK == Sema::ACK_CompAssign; bool IsCompAssign = ACK == Sema::ACK_CompAssign;
if ((!IsCompAssign && LEnum && R->isFloatingType()) || if ((!IsCompAssign && LEnum && R->isFloatingType()) ||
(REnum && L->isFloatingType())) { (REnum && L->isFloatingType())) {
S.Diag(Loc, S.getLangOpts().CPlusPlus2a S.Diag(Loc, S.getLangOpts().CPlusPlus20
? diag::warn_arith_conv_enum_float_cxx2a ? diag::warn_arith_conv_enum_float_cxx2a
: diag::warn_arith_conv_enum_float) : diag::warn_arith_conv_enum_float)
<< LHS->getSourceRange() << RHS->getSourceRange() << LHS->getSourceRange() << RHS->getSourceRange()
<< (int)ACK << LEnum << L << R; << (int)ACK << LEnum << L << R;
} else if (!IsCompAssign && LEnum && REnum && } else if (!IsCompAssign && LEnum && REnum &&
!S.Context.hasSameUnqualifiedType(L, R)) { !S.Context.hasSameUnqualifiedType(L, R)) {
unsigned DiagID; unsigned DiagID;
if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() || if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() ||
!R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) { !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {
// If either enumeration type is unnamed, it's less likely that the // If either enumeration type is unnamed, it's less likely that the
// user cares about this, but this situation is still deprecated in // user cares about this, but this situation is still deprecated in
// C++2a. Use a different warning group. // C++2a. Use a different warning group.
DiagID = S.getLangOpts().CPlusPlus2a DiagID = S.getLangOpts().CPlusPlus20
? diag::warn_arith_conv_mixed_anon_enum_types_cxx2a ? diag::warn_arith_conv_mixed_anon_enum_types_cxx2a
: diag::warn_arith_conv_mixed_anon_enum_types; : diag::warn_arith_conv_mixed_anon_enum_types;
} else if (ACK == Sema::ACK_Conditional) { } else if (ACK == Sema::ACK_Conditional) {
// Conditional expressions are separated out because they have // Conditional expressions are separated out because they have
// historically had a different warning flag. // historically had a different warning flag.
DiagID = S.getLangOpts().CPlusPlus2a DiagID = S.getLangOpts().CPlusPlus20
? diag::warn_conditional_mixed_enum_types_cxx2a ? diag::warn_conditional_mixed_enum_types_cxx2a
: diag::warn_conditional_mixed_enum_types; : diag::warn_conditional_mixed_enum_types;
} else if (ACK == Sema::ACK_Comparison) { } else if (ACK == Sema::ACK_Comparison) {
// Comparison expressions are separated out because they have // Comparison expressions are separated out because they have
// historically had a different warning flag. // historically had a different warning flag.
DiagID = S.getLangOpts().CPlusPlus2a DiagID = S.getLangOpts().CPlusPlus20
? diag::warn_comparison_mixed_enum_types_cxx2a ? diag::warn_comparison_mixed_enum_types_cxx2a
: diag::warn_comparison_mixed_enum_types; : diag::warn_comparison_mixed_enum_types;
} else { } else {
DiagID = S.getLangOpts().CPlusPlus2a DiagID = S.getLangOpts().CPlusPlus20
? diag::warn_arith_conv_mixed_enum_types_cxx2a ? diag::warn_arith_conv_mixed_enum_types_cxx2a
: diag::warn_arith_conv_mixed_enum_types; : diag::warn_arith_conv_mixed_enum_types;
} }
S.Diag(Loc, DiagID) << LHS->getSourceRange() << RHS->getSourceRange() S.Diag(Loc, DiagID) << LHS->getSourceRange() << RHS->getSourceRange()
<< (int)ACK << L << R; << (int)ACK << L << R;
} }
} }
▲ Show 20 Lines • Show All 334 Lines • ▼ Show 20 Lines
CharTy = Context.Char32Ty; CharTy = Context.Char32Ty;
Kind = StringLiteral::UTF32; Kind = StringLiteral::UTF32;
} else if (Literal.isPascal()) { } else if (Literal.isPascal()) {
CharTy = Context.UnsignedCharTy; CharTy = Context.UnsignedCharTy;
} }
// Warn on initializing an array of char from a u8 string literal; this // Warn on initializing an array of char from a u8 string literal; this
// becomes ill-formed in C++2a. // becomes ill-formed in C++2a.
if (getLangOpts().CPlusPlus && !getLangOpts().CPlusPlus2a && if (getLangOpts().CPlusPlus && !getLangOpts().CPlusPlus20 &&
!getLangOpts().Char8 && Kind == StringLiteral::UTF8) { !getLangOpts().Char8 && Kind == StringLiteral::UTF8) {
Diag(StringTokLocs.front(), diag::warn_cxx2a_compat_utf8_string); Diag(StringTokLocs.front(), diag::warn_cxx2a_compat_utf8_string);
// Create removals for all 'u8' prefixes in the string literal(s). This // Create removals for all 'u8' prefixes in the string literal(s). This
// ensures C++2a compatibility (but may change the program behavior when // ensures C++2a compatibility (but may change the program behavior when
// built by non-Clang compilers for which the execution character set is // built by non-Clang compilers for which the execution character set is
// not always UTF-8). // not always UTF-8).
auto RemovalDiag = PDiag(diag::note_cxx2a_compat_utf8_string_remove_u8); auto RemovalDiag = PDiag(diag::note_cxx2a_compat_utf8_string_remove_u8);
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
// Since this might be a postfix expression, get rid of ParenListExprs. // Since this might be a postfix expression, get rid of ParenListExprs.
if (isa<ParenListExpr>(base)) { if (isa<ParenListExpr>(base)) {
ExprResult result = MaybeConvertParenListExprToParenExpr(S, base); ExprResult result = MaybeConvertParenListExprToParenExpr(S, base);
if (result.isInvalid()) return ExprError(); if (result.isInvalid()) return ExprError();
base = result.get(); base = result.get();
} }
// A comma-expression as the index is deprecated in C++2a onwards. // A comma-expression as the index is deprecated in C++2a onwards.
if (getLangOpts().CPlusPlus2a && if (getLangOpts().CPlusPlus20 &&
((isa<BinaryOperator>(idx) && cast<BinaryOperator>(idx)->isCommaOp()) || ((isa<BinaryOperator>(idx) && cast<BinaryOperator>(idx)->isCommaOp()) ||
(isa<CXXOperatorCallExpr>(idx) && (isa<CXXOperatorCallExpr>(idx) &&
cast<CXXOperatorCallExpr>(idx)->getOperator() == OO_Comma))) { cast<CXXOperatorCallExpr>(idx)->getOperator() == OO_Comma))) {
Diag(idx->getExprLoc(), diag::warn_deprecated_comma_subscript) Diag(idx->getExprLoc(), diag::warn_deprecated_comma_subscript)
<< SourceRange(base->getBeginLoc(), rbLoc); << SourceRange(base->getBeginLoc(), rbLoc);
} }
// Handle any non-overload placeholder types in the base and index // Handle any non-overload placeholder types in the base and index
▲ Show 20 Lines • Show All 1,603 Lines • ▼ Show 20 Lines
if (Call.isInvalid()) if (Call.isInvalid())
return Call; return Call;
// Diagnose uses of the C++20 "ADL-only template-id call" feature in earlier // Diagnose uses of the C++20 "ADL-only template-id call" feature in earlier
// language modes. // language modes.
if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn)) { if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn)) {
if (ULE->hasExplicitTemplateArgs() && if (ULE->hasExplicitTemplateArgs() &&
ULE->decls_begin() == ULE->decls_end()) { ULE->decls_begin() == ULE->decls_end()) {
Diag(Fn->getExprLoc(), getLangOpts().CPlusPlus2a Diag(Fn->getExprLoc(), getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_adl_only_template_id ? diag::warn_cxx17_compat_adl_only_template_id
: diag::ext_adl_only_template_id) : diag::ext_adl_only_template_id)
<< ULE->getName(); << ULE->getName();
} }
} }
if (LangOpts.OpenMP) if (LangOpts.OpenMP)
Call = ActOnOpenMPCall(Call, Scope, LParenLoc, ArgExprs, RParenLoc, Call = ActOnOpenMPCall(Call, Scope, LParenLoc, ArgExprs, RParenLoc,
▲ Show 20 Lines • Show All 604 Lines • ▼ Show 20 Lines
} }
} }
if (FirstDesignator.isValid()) { if (FirstDesignator.isValid()) {
// Only diagnose designated initiaization as a C++20 extension if we didn't // Only diagnose designated initiaization as a C++20 extension if we didn't
// already diagnose use of (non-C++20) C99 designator syntax. // already diagnose use of (non-C++20) C99 designator syntax.
if (getLangOpts().CPlusPlus && !DiagnosedArrayDesignator && if (getLangOpts().CPlusPlus && !DiagnosedArrayDesignator &&
!DiagnosedNestedDesignator && !DiagnosedMixedDesignator) { !DiagnosedNestedDesignator && !DiagnosedMixedDesignator) {
Diag(FirstDesignator, getLangOpts().CPlusPlus2a Diag(FirstDesignator, getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_designated_init ? diag::warn_cxx17_compat_designated_init
: diag::ext_cxx_designated_init); : diag::ext_cxx_designated_init);
} else if (!getLangOpts().CPlusPlus && !getLangOpts().C99) { } else if (!getLangOpts().CPlusPlus && !getLangOpts().C99) {
Diag(FirstDesignator, diag::ext_designated_init); Diag(FirstDesignator, diag::ext_designated_init);
} }
} }
return BuildInitList(LBraceLoc, InitArgList, RBraceLoc); return BuildInitList(LBraceLoc, InitArgList, RBraceLoc);
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
LHSType->hasUnsignedIntegerRepresentation() || LHSType->hasUnsignedIntegerRepresentation() ||
!LHS.get()->EvaluateAsInt(LHSResult, S.Context)) !LHS.get()->EvaluateAsInt(LHSResult, S.Context))
return; return;
llvm::APSInt Left = LHSResult.Val.getInt(); llvm::APSInt Left = LHSResult.Val.getInt();
// If LHS does not have a signed type and non-negative value // If LHS does not have a signed type and non-negative value
// then, the behavior is undefined before C++2a. Warn about it. // then, the behavior is undefined before C++2a. Warn about it.
if (Left.isNegative() && !S.getLangOpts().isSignedOverflowDefined() && if (Left.isNegative() && !S.getLangOpts().isSignedOverflowDefined() &&
!S.getLangOpts().CPlusPlus2a) { !S.getLangOpts().CPlusPlus20) {
S.DiagRuntimeBehavior(Loc, LHS.get(), S.DiagRuntimeBehavior(Loc, LHS.get(),
S.PDiag(diag::warn_shift_lhs_negative) S.PDiag(diag::warn_shift_lhs_negative)
<< LHS.get()->getSourceRange()); << LHS.get()->getSourceRange());
return; return;
} }
llvm::APInt ResultBits = llvm::APInt ResultBits =
static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits(); static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits();
▲ Show 20 Lines • Show All 463 Lines • ▼ Show 20 Lines
AlwaysTrue, AlwaysTrue,
AlwaysFalse, AlwaysFalse,
AlwaysEqual, // std::strong_ordering::equal from operator<=> AlwaysEqual, // std::strong_ordering::equal from operator<=>
}; };
// C++2a [depr.array.comp]: // C++2a [depr.array.comp]:
// Equality and relational comparisons ([expr.eq], [expr.rel]) between two // Equality and relational comparisons ([expr.eq], [expr.rel]) between two
// operands of array type are deprecated. // operands of array type are deprecated.
if (S.getLangOpts().CPlusPlus2a && LHSStripped->getType()->isArrayType() && if (S.getLangOpts().CPlusPlus20 && LHSStripped->getType()->isArrayType() &&
RHSStripped->getType()->isArrayType()) { RHSStripped->getType()->isArrayType()) {
S.Diag(Loc, diag::warn_depr_array_comparison) S.Diag(Loc, diag::warn_depr_array_comparison)
<< LHS->getSourceRange() << RHS->getSourceRange() << LHS->getSourceRange() << RHS->getSourceRange()
<< LHSStripped->getType() << RHSStripped->getType(); << LHSStripped->getType() << RHSStripped->getType();
// Carry on to produce the tautological comparison warning, if this // Carry on to produce the tautological comparison warning, if this
// expression is potentially-evaluated, we can resolve the array to a // expression is potentially-evaluated, we can resolve the array to a
// non-weak declaration, and so on. // non-weak declaration, and so on.
} }
▲ Show 20 Lines • Show All 1,629 Lines • ▼ Show 20 Lines
} }
if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType, if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
RHS.get(), AA_Assigning)) RHS.get(), AA_Assigning))
return QualType(); return QualType();
CheckForNullPointerDereference(*this, LHSExpr); CheckForNullPointerDereference(*this, LHSExpr);
if (getLangOpts().CPlusPlus2a && LHSType.isVolatileQualified()) { if (getLangOpts().CPlusPlus20 && LHSType.isVolatileQualified()) {
if (CompoundType.isNull()) { if (CompoundType.isNull()) {
// C++2a [expr.ass]p5: // C++2a [expr.ass]p5:
// A simple-assignment whose left operand is of a volatile-qualified // A simple-assignment whose left operand is of a volatile-qualified
// type is deprecated unless the assignment is either a discarded-value // type is deprecated unless the assignment is either a discarded-value
// expression or an unevaluated operand // expression or an unevaluated operand
ExprEvalContexts.back().VolatileAssignmentLHSs.push_back(LHSExpr); ExprEvalContexts.back().VolatileAssignmentLHSs.push_back(LHSExpr);
} else { } else {
// C++2a [expr.ass]p6: // C++2a [expr.ass]p6:
▲ Show 20 Lines • Show All 186 Lines • ▼ Show 20 Lines
S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement) S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
<< ResType << int(IsInc) << Op->getSourceRange(); << ResType << int(IsInc) << Op->getSourceRange();
return QualType(); return QualType();
} }
// At this point, we know we have a real, complex or pointer type. // At this point, we know we have a real, complex or pointer type.
// Now make sure the operand is a modifiable lvalue. // Now make sure the operand is a modifiable lvalue.
if (CheckForModifiableLvalue(Op, OpLoc, S)) if (CheckForModifiableLvalue(Op, OpLoc, S))
return QualType(); return QualType();
if (S.getLangOpts().CPlusPlus2a && ResType.isVolatileQualified()) { if (S.getLangOpts().CPlusPlus20 && ResType.isVolatileQualified()) {
// C++2a [expr.pre.inc]p1, [expr.post.inc]p1: // C++2a [expr.pre.inc]p1, [expr.post.inc]p1:
// An operand with volatile-qualified type is deprecated // An operand with volatile-qualified type is deprecated
S.Diag(OpLoc, diag::warn_deprecated_increment_decrement_volatile) S.Diag(OpLoc, diag::warn_deprecated_increment_decrement_volatile)
<< IsInc << ResType; << IsInc << ResType;
} }
// In C++, a prefix increment is the same type as the operand. Otherwise // In C++, a prefix increment is the same type as the operand. Otherwise
// (in C or with postfix), the increment is the unqualified type of the // (in C or with postfix), the increment is the unqualified type of the
// operand. // operand.
▲ Show 20 Lines • Show All 1,158 Lines • ▼ Show 20 Lines
UnresolvedSet<16> Functions; UnresolvedSet<16> Functions;
OverloadedOperatorKind OverOp OverloadedOperatorKind OverOp
= BinaryOperator::getOverloadedOperator(Opc); = BinaryOperator::getOverloadedOperator(Opc);
if (Sc && OverOp != OO_None && OverOp != OO_Equal) if (Sc && OverOp != OO_None && OverOp != OO_Equal)
S.LookupOverloadedOperatorName(OverOp, Sc, LHS->getType(), S.LookupOverloadedOperatorName(OverOp, Sc, LHS->getType(),
RHS->getType(), Functions); RHS->getType(), Functions);
// In C++20 onwards, we may have a second operator to look up. // In C++20 onwards, we may have a second operator to look up.
if (S.getLangOpts().CPlusPlus2a) { if (S.getLangOpts().CPlusPlus20) {
if (OverloadedOperatorKind ExtraOp = getRewrittenOverloadedOperator(OverOp)) if (OverloadedOperatorKind ExtraOp = getRewrittenOverloadedOperator(OverOp))
S.LookupOverloadedOperatorName(ExtraOp, Sc, LHS->getType(), S.LookupOverloadedOperatorName(ExtraOp, Sc, LHS->getType(),
RHS->getType(), Functions); RHS->getType(), Functions);
} }
// Build the (potentially-overloaded, potentially-dependent) // Build the (potentially-overloaded, potentially-dependent)
// binary operation. // binary operation.
return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS); return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS);
▲ Show 20 Lines • Show All 1,883 Lines • ▼ Show 20 Lines
Rec.PossibleDerefs.clear(); Rec.PossibleDerefs.clear();
} }
/// Check whether E, which is either a discarded-value expression or an /// Check whether E, which is either a discarded-value expression or an
/// unevaluated operand, is a simple-assignment to a volatlie-qualified lvalue, /// unevaluated operand, is a simple-assignment to a volatlie-qualified lvalue,
/// and if so, remove it from the list of volatile-qualified assignments that /// and if so, remove it from the list of volatile-qualified assignments that
/// we are going to warn are deprecated. /// we are going to warn are deprecated.
void Sema::CheckUnusedVolatileAssignment(Expr *E) { void Sema::CheckUnusedVolatileAssignment(Expr *E) {
if (!E->getType().isVolatileQualified() || !getLangOpts().CPlusPlus2a) if (!E->getType().isVolatileQualified() || !getLangOpts().CPlusPlus20)
return; return;
// Note: ignoring parens here is not justified by the standard rules, but // Note: ignoring parens here is not justified by the standard rules, but
// ignoring parentheses seems like a more reasonable approach, and this only // ignoring parentheses seems like a more reasonable approach, and this only
// drives a deprecation warning so doesn't affect conformance. // drives a deprecation warning so doesn't affect conformance.
if (auto *BO = dyn_cast<BinaryOperator>(E->IgnoreParenImpCasts())) { if (auto *BO = dyn_cast<BinaryOperator>(E->IgnoreParenImpCasts())) {
if (BO->getOpcode() == BO_Assign) { if (BO->getOpcode() == BO_Assign) {
auto &LHSs = ExprEvalContexts.back().VolatileAssignmentLHSs; auto &LHSs = ExprEvalContexts.back().VolatileAssignmentLHSs;
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Sema/SemaExprCXX.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
// Do nothing // Do nothing
break; break;
case RQ_LValue: case RQ_LValue:
if (!isIndirect && !LHS.get()->Classify(Context).isLValue()) { if (!isIndirect && !LHS.get()->Classify(Context).isLValue()) {
// C++2a allows functions with ref-qualifier & if their cv-qualifier-seq // C++2a allows functions with ref-qualifier & if their cv-qualifier-seq
// is (exactly) 'const'. // is (exactly) 'const'.
if (Proto->isConst() && !Proto->isVolatile()) if (Proto->isConst() && !Proto->isVolatile())
Diag(Loc, getLangOpts().CPlusPlus2a Diag(Loc, getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
: diag::ext_pointer_to_const_ref_member_on_rvalue); : diag::ext_pointer_to_const_ref_member_on_rvalue);
else else
Diag(Loc, diag::err_pointer_to_member_oper_value_classify) Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
<< RHSType << 1 << LHS.get()->getSourceRange(); << RHSType << 1 << LHS.get()->getSourceRange();
} }
break; break;
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Sema/SemaInit.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
diag::err_array_init_plain_string_into_char8_t); diag::err_array_init_plain_string_into_char8_t);
S.Diag(Args.front()->getBeginLoc(), S.Diag(Args.front()->getBeginLoc(),
diag::note_array_init_plain_string_into_char8_t) diag::note_array_init_plain_string_into_char8_t)
<< FixItHint::CreateInsertion(Args.front()->getBeginLoc(), "u8"); << FixItHint::CreateInsertion(Args.front()->getBeginLoc(), "u8");
break; break;
case FK_UTF8StringIntoPlainChar: case FK_UTF8StringIntoPlainChar:
S.Diag(Kind.getLocation(), S.Diag(Kind.getLocation(),
diag::err_array_init_utf8_string_into_char) diag::err_array_init_utf8_string_into_char)
<< S.getLangOpts().CPlusPlus2a; << S.getLangOpts().CPlusPlus20;
break; break;
case FK_ArrayTypeMismatch: case FK_ArrayTypeMismatch:
case FK_NonConstantArrayInit: case FK_NonConstantArrayInit:
S.Diag(Kind.getLocation(), S.Diag(Kind.getLocation(),
(Failure == FK_ArrayTypeMismatch (Failure == FK_ArrayTypeMismatch
? diag::err_array_init_different_type ? diag::err_array_init_different_type
: diag::err_array_init_non_constant_array)) : diag::err_array_init_non_constant_array))
<< DestType.getNonReferenceType() << DestType.getNonReferenceType()
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Sema/SemaLambda.cpp

Show First 20 Lines • Show All 794 Lines • ▼ Show 20 LinesQualType Sema::buildLambdaInitCaptureInitialization(
TL.setNameLoc(Loc); TL.setNameLoc(Loc);
if (ByRef) { if (ByRef) {
DeductType = BuildReferenceType(DeductType, true, Loc, Id); DeductType = BuildReferenceType(DeductType, true, Loc, Id);
assert(!DeductType.isNull() && "can't build reference to auto"); assert(!DeductType.isNull() && "can't build reference to auto");
TLB.push<ReferenceTypeLoc>(DeductType).setSigilLoc(Loc); TLB.push<ReferenceTypeLoc>(DeductType).setSigilLoc(Loc);
} }
if (EllipsisLoc.isValid()) { if (EllipsisLoc.isValid()) {
if (Init->containsUnexpandedParameterPack()) { if (Init->containsUnexpandedParameterPack()) {
Diag(EllipsisLoc, getLangOpts().CPlusPlus2a Diag(EllipsisLoc, getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_init_capture_pack ? diag::warn_cxx17_compat_init_capture_pack
: diag::ext_init_capture_pack); : diag::ext_init_capture_pack);
DeductType = Context.getPackExpansionType(DeductType, NumExpansions); DeductType = Context.getPackExpansionType(DeductType, NumExpansions);
TLB.push<PackExpansionTypeLoc>(DeductType).setEllipsisLoc(EllipsisLoc); TLB.push<PackExpansionTypeLoc>(DeductType).setEllipsisLoc(EllipsisLoc);
} else { } else {
// Just ignore the ellipsis for now and form a non-pack variable. We'll // Just ignore the ellipsis for now and form a non-pack variable. We'll
// diagnose this later when we try to capture it. // diagnose this later when we try to capture it.
} }
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Lines if (C->Kind == LCK_This || C->Kind == LCK_StarThis) {
} }
// C++2a [expr.prim.lambda]p8: // C++2a [expr.prim.lambda]p8:
// If a lambda-capture includes a capture-default that is =, // If a lambda-capture includes a capture-default that is =,
// each simple-capture of that lambda-capture shall be of the form // each simple-capture of that lambda-capture shall be of the form
// "&identifier", "this", or "* this". [ Note: The form [&,this] is // "&identifier", "this", or "* this". [ Note: The form [&,this] is
// redundant but accepted for compatibility with ISO C++14. --end note ] // redundant but accepted for compatibility with ISO C++14. --end note ]
if (Intro.Default == LCD_ByCopy && C->Kind != LCK_StarThis) if (Intro.Default == LCD_ByCopy && C->Kind != LCK_StarThis)
Diag(C->Loc, !getLangOpts().CPlusPlus2a Diag(C->Loc, !getLangOpts().CPlusPlus20
? diag::ext_equals_this_lambda_capture_cxx2a ? diag::ext_equals_this_lambda_capture_cxx2a
: diag::warn_cxx17_compat_equals_this_lambda_capture); : diag::warn_cxx17_compat_equals_this_lambda_capture);
// C++11 [expr.prim.lambda]p12: // C++11 [expr.prim.lambda]p12:
// If this is captured by a local lambda expression, its nearest // If this is captured by a local lambda expression, its nearest
// enclosing function shall be a non-static member function. // enclosing function shall be a non-static member function.
QualType ThisCaptureType = getCurrentThisType(); QualType ThisCaptureType = getCurrentThisType();
if (ThisCaptureType.isNull()) { if (ThisCaptureType.isNull()) {
▲ Show 20 Lines • Show All 678 Lines • ▼ Show 20 Lines for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I) {
} }
// Map the capture to our AST representation. // Map the capture to our AST representation.
LambdaCapture Capture = [&] { LambdaCapture Capture = [&] {
if (From.isThisCapture()) { if (From.isThisCapture()) {
// Capturing 'this' implicitly with a default of '[=]' is deprecated, // Capturing 'this' implicitly with a default of '[=]' is deprecated,
// because it results in a reference capture. Don't warn prior to // because it results in a reference capture. Don't warn prior to
// C++2a; there's nothing that can be done about it before then. // C++2a; there's nothing that can be done about it before then.
if (getLangOpts().CPlusPlus2a && IsImplicit && if (getLangOpts().CPlusPlus20 && IsImplicit &&
CaptureDefault == LCD_ByCopy) { CaptureDefault == LCD_ByCopy) {
Diag(From.getLocation(), diag::warn_deprecated_this_capture); Diag(From.getLocation(), diag::warn_deprecated_this_capture);
Diag(CaptureDefaultLoc, diag::note_deprecated_this_capture) Diag(CaptureDefaultLoc, diag::note_deprecated_this_capture)
<< FixItHint::CreateInsertion( << FixItHint::CreateInsertion(
getLocForEndOfToken(CaptureDefaultLoc), ", this"); getLocForEndOfToken(CaptureDefaultLoc), ", this");
} }
return LambdaCapture(From.getLocation(), IsImplicit, return LambdaCapture(From.getLocation(), IsImplicit,
From.isCopyCapture() ? LCK_StarThis : LCK_This); From.isCopyCapture() ? LCK_StarThis : LCK_This);
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

clang/lib/Sema/SemaOverload.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
BinaryOperatorKind Opc, BinaryOperatorKind Opc,
const UnresolvedSetImpl &Fns, Expr *LHS, const UnresolvedSetImpl &Fns, Expr *LHS,
Expr *RHS, bool PerformADL, Expr *RHS, bool PerformADL,
bool AllowRewrittenCandidates, bool AllowRewrittenCandidates,
FunctionDecl *DefaultedFn) { FunctionDecl *DefaultedFn) {
Expr *Args[2] = { LHS, RHS }; Expr *Args[2] = { LHS, RHS };
LHS=RHS=nullptr; // Please use only Args instead of LHS/RHS couple LHS=RHS=nullptr; // Please use only Args instead of LHS/RHS couple
if (!getLangOpts().CPlusPlus2a) if (!getLangOpts().CPlusPlus20)
AllowRewrittenCandidates = false; AllowRewrittenCandidates = false;
OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc); OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc);
// If either side is type-dependent, create an appropriate dependent // If either side is type-dependent, create an appropriate dependent
// expression. // expression.
if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) { if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
if (Fns.empty()) { if (Fns.empty()) {
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Sema/SemaTemplate.cpp

Show First 20 Lines • Show All 479 Lines • ▼ Show 20 Lines
// A name is also considered to refer to a template if it is an // A name is also considered to refer to a template if it is an
// unqualified-id followed by a < and name lookup finds either one or more // unqualified-id followed by a < and name lookup finds either one or more
// functions or finds nothing. // functions or finds nothing.
// //
// To keep our behavior consistent, we apply the "finds nothing" part in // To keep our behavior consistent, we apply the "finds nothing" part in
// all language modes, and diagnose the empty lookup in ActOnCallExpr if we // all language modes, and diagnose the empty lookup in ActOnCallExpr if we
// successfully form a call to an undeclared template-id. // successfully form a call to an undeclared template-id.
bool AllFunctions = bool AllFunctions =
getLangOpts().CPlusPlus2a && getLangOpts().CPlusPlus20 &&
std::all_of(Found.begin(), Found.end(), [](NamedDecl *ND) { std::all_of(Found.begin(), Found.end(), [](NamedDecl *ND) {
return isa<FunctionDecl>(ND->getUnderlyingDecl()); return isa<FunctionDecl>(ND->getUnderlyingDecl());
}); });
if (AllFunctions || (Found.empty() && !IsDependent)) { if (AllFunctions || (Found.empty() && !IsDependent)) {
// If lookup found any functions, or if this is a name that can only be // If lookup found any functions, or if this is a name that can only be
// used for a function, then strongly assume this is a function // used for a function, then strongly assume this is a function
// template-id. // template-id.
*ATK = (Found.empty() && Found.getLookupName().isIdentifier()) *ATK = (Found.empty() && Found.getLookupName().isIdentifier())
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
InstantiationDependent)) { InstantiationDependent)) {
Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized) Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
<< VarTemplate->getDeclName(); << VarTemplate->getDeclName();
IsPartialSpecialization = false; IsPartialSpecialization = false;
} }
if (isSameAsPrimaryTemplate(VarTemplate->getTemplateParameters(), if (isSameAsPrimaryTemplate(VarTemplate->getTemplateParameters(),
Converted) && Converted) &&
(!Context.getLangOpts().CPlusPlus2a || (!Context.getLangOpts().CPlusPlus20 ||
!TemplateParams->hasAssociatedConstraints())) { !TemplateParams->hasAssociatedConstraints())) {
// C++ [temp.class.spec]p9b3: // C++ [temp.class.spec]p9b3:
// //
// -- The argument list of the specialization shall not be identical // -- The argument list of the specialization shall not be identical
// to the implicit argument list of the primary template. // to the implicit argument list of the primary template.
Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template) Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
<< /*variable template*/ 1 << /*variable template*/ 1
<< /*is definition*/(SC != SC_Extern && !CurContext->isRecord()) << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
// Build the canonical type that describes the converted template // Build the canonical type that describes the converted template
// arguments of the class template partial specialization. // arguments of the class template partial specialization.
TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name); TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
CanonType = Context.getTemplateSpecializationType(CanonTemplate, CanonType = Context.getTemplateSpecializationType(CanonTemplate,
Converted); Converted);
if (Context.hasSameType(CanonType, if (Context.hasSameType(CanonType,
ClassTemplate->getInjectedClassNameSpecialization()) && ClassTemplate->getInjectedClassNameSpecialization()) &&
(!Context.getLangOpts().CPlusPlus2a || (!Context.getLangOpts().CPlusPlus20 ||
!TemplateParams->hasAssociatedConstraints())) { !TemplateParams->hasAssociatedConstraints())) {
// C++ [temp.class.spec]p9b3: // C++ [temp.class.spec]p9b3:
// //
// -- The argument list of the specialization shall not be identical // -- The argument list of the specialization shall not be identical
// to the implicit argument list of the primary template. // to the implicit argument list of the primary template.
// //
// This rule has since been removed, because it's redundant given DR1495, // This rule has since been removed, because it's redundant given DR1495,
// but we keep it because it produces better diagnostics and recovery. // but we keep it because it produces better diagnostics and recovery.
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/lib/Sema/SemaType.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
if (T.hasNonTrivialToPrimitiveDestructCUnion() || if (T.hasNonTrivialToPrimitiveDestructCUnion() ||
T.hasNonTrivialToPrimitiveCopyCUnion()) T.hasNonTrivialToPrimitiveCopyCUnion())
checkNonTrivialCUnion(T, Loc, NTCUC_FunctionReturn, checkNonTrivialCUnion(T, Loc, NTCUC_FunctionReturn,
NTCUK_Destruct|NTCUK_Copy); NTCUK_Destruct|NTCUK_Copy);
// C++2a [dcl.fct]p12: // C++2a [dcl.fct]p12:
// A volatile-qualified return type is deprecated // A volatile-qualified return type is deprecated
if (T.isVolatileQualified() && getLangOpts().CPlusPlus2a) if (T.isVolatileQualified() && getLangOpts().CPlusPlus20)
Diag(Loc, diag::warn_deprecated_volatile_return) << T; Diag(Loc, diag::warn_deprecated_volatile_return) << T;
return false; return false;
} }
/// Check the extended parameter information. Most of the necessary /// Check the extended parameter information. Most of the necessary
/// checking should occur when applying the parameter attribute; the /// checking should occur when applying the parameter attribute; the
/// only other checks required are positional restrictions. /// only other checks required are positional restrictions.
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
// Disallow half FP arguments. // Disallow half FP arguments.
Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 << Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
FixItHint::CreateInsertion(Loc, "*"); FixItHint::CreateInsertion(Loc, "*");
Invalid = true; Invalid = true;
} }
// C++2a [dcl.fct]p4: // C++2a [dcl.fct]p4:
// A parameter with volatile-qualified type is deprecated // A parameter with volatile-qualified type is deprecated
if (ParamType.isVolatileQualified() && getLangOpts().CPlusPlus2a) if (ParamType.isVolatileQualified() && getLangOpts().CPlusPlus20)
Diag(Loc, diag::warn_deprecated_volatile_param) << ParamType; Diag(Loc, diag::warn_deprecated_volatile_param) << ParamType;
ParamTypes[Idx] = ParamType; ParamTypes[Idx] = ParamType;
} }
if (EPI.ExtParameterInfos) { if (EPI.ExtParameterInfos) {
checkExtParameterInfos(*this, ParamTypes, EPI, checkExtParameterInfos(*this, ParamTypes, EPI,
[=](unsigned i) { return Loc; }); [=](unsigned i) { return Loc; });
▲ Show 20 Lines • Show All 484 Lines • ▼ Show 20 Lines
case DeclaratorContext::RequiresExprContext: case DeclaratorContext::RequiresExprContext:
Error = 22; Error = 22;
break; break;
case DeclaratorContext::PrototypeContext: case DeclaratorContext::PrototypeContext:
case DeclaratorContext::LambdaExprParameterContext: { case DeclaratorContext::LambdaExprParameterContext: {
InventedTemplateParameterInfo *Info = nullptr; InventedTemplateParameterInfo *Info = nullptr;
if (D.getContext() == DeclaratorContext::PrototypeContext) { if (D.getContext() == DeclaratorContext::PrototypeContext) {
// With concepts we allow 'auto' in function parameters. // With concepts we allow 'auto' in function parameters.
if (!SemaRef.getLangOpts().CPlusPlus2a || !Auto || if (!SemaRef.getLangOpts().CPlusPlus20 || !Auto ||
Auto->getKeyword() != AutoTypeKeyword::Auto) { Auto->getKeyword() != AutoTypeKeyword::Auto) {
Error = 0; Error = 0;
break; break;
} else if (!SemaRef.getCurScope()->isFunctionDeclarationScope()) { } else if (!SemaRef.getCurScope()->isFunctionDeclarationScope()) {
Error = 21; Error = 21;
break; break;
} else if (D.hasTrailingReturnType()) { } else if (D.hasTrailingReturnType()) {
// This might be OK, but we'll need to convert the trailing return // This might be OK, but we'll need to convert the trailing return
▲ Show 20 Lines • Show All 1,598 Lines • ▼ Show 20 Lines
<< T << D.getDeclSpec().getSourceRange(); << T << D.getDeclSpec().getSourceRange();
D.setInvalidType(true); D.setInvalidType(true);
} }
T = S.GetTypeFromParser(FTI.getTrailingReturnType(), &TInfo); T = S.GetTypeFromParser(FTI.getTrailingReturnType(), &TInfo);
if (T.isNull()) { if (T.isNull()) {
// An error occurred parsing the trailing return type. // An error occurred parsing the trailing return type.
T = Context.IntTy; T = Context.IntTy;
D.setInvalidType(true); D.setInvalidType(true);
} else if (S.getLangOpts().CPlusPlus2a) } else if (S.getLangOpts().CPlusPlus20)
// Handle cases like: `auto f() -> auto` or `auto f() -> C auto`. // Handle cases like: `auto f() -> auto` or `auto f() -> C auto`.
if (AutoType *Auto = T->getContainedAutoType()) if (AutoType *Auto = T->getContainedAutoType())
if (S.getCurScope()->isFunctionDeclarationScope()) if (S.getCurScope()->isFunctionDeclarationScope())
T = InventTemplateParameter(state, T, TInfo, Auto, T = InventTemplateParameter(state, T, TInfo, Auto,
S.InventedParameterInfos.back()); S.InventedParameterInfos.back());
} else { } else {
// This function type is not the type of the entity being declared, // This function type is not the type of the entity being declared,
// so checking the 'auto' is not the responsibility of this chunk. // so checking the 'auto' is not the responsibility of this chunk.
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
// function definition. Apparently ok on declarations and // function definition. Apparently ok on declarations and
// in C++ though (!) // in C++ though (!)
S.Diag(DeclType.Loc, diag::err_func_returning_qualified_void) << T; S.Diag(DeclType.Loc, diag::err_func_returning_qualified_void) << T;
} else } else
diagnoseRedundantReturnTypeQualifiers(S, T, D, chunkIndex); diagnoseRedundantReturnTypeQualifiers(S, T, D, chunkIndex);
// C++2a [dcl.fct]p12: // C++2a [dcl.fct]p12:
// A volatile-qualified return type is deprecated // A volatile-qualified return type is deprecated
if (T.isVolatileQualified() && S.getLangOpts().CPlusPlus2a) if (T.isVolatileQualified() && S.getLangOpts().CPlusPlus20)
S.Diag(DeclType.Loc, diag::warn_deprecated_volatile_return) << T; S.Diag(DeclType.Loc, diag::warn_deprecated_volatile_return) << T;
} }
// Objective-C ARC ownership qualifiers are ignored on the function // Objective-C ARC ownership qualifiers are ignored on the function
// return type (by type canonicalization). Complain if this attribute // return type (by type canonicalization). Complain if this attribute
// was written here. // was written here.
if (T.getQualifiers().hasObjCLifetime()) { if (T.getQualifiers().hasObjCLifetime()) {
SourceLocation AttrLoc; SourceLocation AttrLoc;
▲ Show 20 Lines • Show All 474 Lines • ▼ Show 20 Lines
// A constexpr specifier used in an object declaration declares the object // A constexpr specifier used in an object declaration declares the object
// as const. // as const.
if (D.getDeclSpec().getConstexprSpecifier() == CSK_constexpr && if (D.getDeclSpec().getConstexprSpecifier() == CSK_constexpr &&
T->isObjectType()) T->isObjectType())
T.addConst(); T.addConst();
// C++2a [dcl.fct]p4: // C++2a [dcl.fct]p4:
// A parameter with volatile-qualified type is deprecated // A parameter with volatile-qualified type is deprecated
if (T.isVolatileQualified() && S.getLangOpts().CPlusPlus2a && if (T.isVolatileQualified() && S.getLangOpts().CPlusPlus20 &&
(D.getContext() == DeclaratorContext::PrototypeContext || (D.getContext() == DeclaratorContext::PrototypeContext ||
D.getContext() == DeclaratorContext::LambdaExprParameterContext)) D.getContext() == DeclaratorContext::LambdaExprParameterContext))
S.Diag(D.getIdentifierLoc(), diag::warn_deprecated_volatile_param) << T; S.Diag(D.getIdentifierLoc(), diag::warn_deprecated_volatile_param) << T;
// If there was an ellipsis in the declarator, the declaration declares a // If there was an ellipsis in the declarator, the declaration declares a
// parameter pack whose type may be a pack expansion type. // parameter pack whose type may be a pack expansion type.
if (D.hasEllipsis()) { if (D.hasEllipsis()) {
// C++0x [dcl.fct]p13: // C++0x [dcl.fct]p13:
Show All 9 Lines
// parameter pack is a function parameter pack (14.5.3). The type T // parameter pack is a function parameter pack (14.5.3). The type T
// of the declarator-id of the function parameter pack shall contain // of the declarator-id of the function parameter pack shall contain
// a template parameter pack; each template parameter pack in T is // a template parameter pack; each template parameter pack in T is
// expanded by the function parameter pack. // expanded by the function parameter pack.
// //
// We represent function parameter packs as function parameters whose // We represent function parameter packs as function parameters whose
// type is a pack expansion. // type is a pack expansion.
if (!T->containsUnexpandedParameterPack() && if (!T->containsUnexpandedParameterPack() &&
(!LangOpts.CPlusPlus2a || !T->getContainedAutoType())) { (!LangOpts.CPlusPlus20 || !T->getContainedAutoType())) {
S.Diag(D.getEllipsisLoc(), S.Diag(D.getEllipsisLoc(),
diag::err_function_parameter_pack_without_parameter_packs) diag::err_function_parameter_pack_without_parameter_packs)
<< T << D.getSourceRange(); << T << D.getSourceRange();
D.setEllipsisLoc(SourceLocation()); D.setEllipsisLoc(SourceLocation());
} else { } else {
T = Context.getPackExpansionType(T, None); T = Context.getPackExpansionType(T, None);
} }
break; break;
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
if (!I->getType()->isLiteralType(Context) || if (!I->getType()->isLiteralType(Context) ||
I->getType().isVolatileQualified()) { I->getType().isVolatileQualified()) {
Diag(I->getLocation(), diag::note_non_literal_field) Diag(I->getLocation(), diag::note_non_literal_field)
<< RD << I << I->getType() << RD << I << I->getType()
<< I->getType().isVolatileQualified(); << I->getType().isVolatileQualified();
return true; return true;
} }
} }
} else if (getLangOpts().CPlusPlus2a ? !RD->hasConstexprDestructor() } else if (getLangOpts().CPlusPlus20 ? !RD->hasConstexprDestructor()
: !RD->hasTrivialDestructor()) { : !RD->hasTrivialDestructor()) {
// All fields and bases are of literal types, so have trivial or constexpr // All fields and bases are of literal types, so have trivial or constexpr
// destructors. If this class's destructor is non-trivial / non-constexpr, // destructors. If this class's destructor is non-trivial / non-constexpr,
// it must be user-declared. // it must be user-declared.
CXXDestructorDecl *Dtor = RD->getDestructor(); CXXDestructorDecl *Dtor = RD->getDestructor();
assert(Dtor && "class has literal fields and bases but no dtor?"); assert(Dtor && "class has literal fields and bases but no dtor?");
if (!Dtor) if (!Dtor)
return true; return true;
if (getLangOpts().CPlusPlus2a) { if (getLangOpts().CPlusPlus20) {
Diag(Dtor->getLocation(), diag::note_non_literal_non_constexpr_dtor) Diag(Dtor->getLocation(), diag::note_non_literal_non_constexpr_dtor)
<< RD; << RD;
} else { } else {
Diag(Dtor->getLocation(), Dtor->isUserProvided() Diag(Dtor->getLocation(), Dtor->isUserProvided()
? diag::note_non_literal_user_provided_dtor ? diag::note_non_literal_user_provided_dtor
: diag::note_non_literal_nontrivial_dtor) : diag::note_non_literal_nontrivial_dtor)
<< RD; << RD;
if (!Dtor->isUserProvided()) if (!Dtor->isUserProvided())
▲ Show 20 Lines • Show All 206 Lines • Show Last 20 Lines

clang/lib/StaticAnalyzer/Core/BasicValueFactory.cpp

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Lines case BO_Shl: {
if (V2.isSigned() && V2.isNegative()) if (V2.isSigned() && V2.isNegative())
return nullptr; return nullptr;
uint64_t Amt = V2.getZExtValue(); uint64_t Amt = V2.getZExtValue();
if (Amt >= V1.getBitWidth()) if (Amt >= V1.getBitWidth())
return nullptr; return nullptr;
if (!Ctx.getLangOpts().CPlusPlus2a) { if (!Ctx.getLangOpts().CPlusPlus20) {
if (V1.isSigned() && V1.isNegative()) if (V1.isSigned() && V1.isNegative())
return nullptr; return nullptr;
if (V1.isSigned() && Amt > V1.countLeadingZeros()) if (V1.isSigned() && Amt > V1.countLeadingZeros())
return nullptr; return nullptr;
} }
return &getValue( V1.operator<<( (unsigned) Amt )); return &getValue( V1.operator<<( (unsigned) Amt ));
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines