[clang-tools-extra] 7e29da8 - Add support for return values in bugprone-stringview-nullptr
CJ Johnson via cfe-commits
cfe-commits at lists.llvm.org
Wed Jan 12 13:57:28 PST 2022
Author: CJ Johnson
Date: 2022-01-12T16:53:13-05:00
New Revision: 7e29da875ca95cd916e7ce6668fa85b638c3bd5f
URL: https://github.com/llvm/llvm-project/commit/7e29da875ca95cd916e7ce6668fa85b638c3bd5f
DIFF: https://github.com/llvm/llvm-project/commit/7e29da875ca95cd916e7ce6668fa85b638c3bd5f.diff
LOG: Add support for return values in bugprone-stringview-nullptr
bugprone-stringview-nullptr was not initially written with tests for return statements. After landing the check, the thought crossed my mind to add such tests. After writing them, I realized they needed additional handling in the matchers.
Differential Revision: https://reviews.llvm.org/D115121
Added:
Modified:
clang-tools-extra/clang-tidy/bugprone/StringviewNullptrCheck.cpp
clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp
Removed:
################################################################################
diff --git a/clang-tools-extra/clang-tidy/bugprone/StringviewNullptrCheck.cpp b/clang-tools-extra/clang-tidy/bugprone/StringviewNullptrCheck.cpp
index 1f7dc48bbe8fb..a0ae262318914 100644
--- a/clang-tools-extra/clang-tidy/bugprone/StringviewNullptrCheck.cpp
+++ b/clang-tools-extra/clang-tidy/bugprone/StringviewNullptrCheck.cpp
@@ -9,6 +9,8 @@
#include "StringviewNullptrCheck.h"
#include "../utils/TransformerClangTidyCheck.h"
#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/OperationKinds.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Tooling/Transformer/RangeSelector.h"
@@ -24,15 +26,24 @@ using namespace ::clang::ast_matchers;
using namespace ::clang::transformer;
namespace {
+
AST_MATCHER_P(InitListExpr, initCountIs, unsigned, N) {
return Node.getNumInits() == N;
}
+
+AST_MATCHER(clang::VarDecl, isDirectInitialization) {
+ return Node.getInitStyle() != clang::VarDecl::InitializationStyle::CInit;
+}
+
} // namespace
RewriteRule StringviewNullptrCheckImpl() {
auto construction_warning =
cat("constructing basic_string_view from null is undefined; replace with "
"the default constructor");
+ auto static_cast_warning =
+ cat("casting to basic_string_view from null is undefined; replace with "
+ "the empty string");
auto assignment_warning =
cat("assignment to basic_string_view from null is undefined; replace "
"with the default constructor");
@@ -42,143 +53,247 @@ RewriteRule StringviewNullptrCheckImpl() {
auto equality_comparison_warning =
cat("comparing basic_string_view to null is undefined; replace with the "
"emptiness query");
- auto StringViewConstructingFromNullExpr =
+ auto constructor_argument_warning =
+ cat("passing null as basic_string_view is undefined; replace with the "
+ "empty string");
+
+ // Matches declarations and expressions of type `basic_string_view`
+ auto HasBasicStringViewType = hasType(hasUnqualifiedDesugaredType(recordType(
+ hasDeclaration(cxxRecordDecl(hasName("::std::basic_string_view"))))));
+
+ // Matches `nullptr` and `(nullptr)` binding to a pointer
+ auto NullLiteral = implicitCastExpr(
+ hasCastKind(clang::CK_NullToPointer),
+ hasSourceExpression(ignoringParens(cxxNullPtrLiteralExpr())));
+
+ // Matches `{nullptr}` and `{(nullptr)}` binding to a pointer
+ auto NullInitList = initListExpr(initCountIs(1), hasInit(0, NullLiteral));
+
+ // Matches `{}`
+ auto EmptyInitList = initListExpr(initCountIs(0));
+
+ // Matches null construction without `basic_string_view` type spelling
+ auto BasicStringViewConstructingFromNullExpr =
cxxConstructExpr(
- hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(
- cxxRecordDecl(hasName("::std::basic_string_view")))))),
- argumentCountIs(1),
- hasArgument(
- 0, anyOf(ignoringParenImpCasts(cxxNullPtrLiteralExpr()),
- initListExpr(initCountIs(1),
- hasInit(0, ignoringParenImpCasts(
- cxxNullPtrLiteralExpr()))),
- initListExpr(initCountIs(0)))),
- has(expr().bind("null_argument_expr")))
+ HasBasicStringViewType, argumentCountIs(1),
+ hasAnyArgument(/* `hasArgument` would skip over parens */ anyOf(
+ NullLiteral, NullInitList, EmptyInitList)),
+ unless(cxxTemporaryObjectExpr(/* filters out type spellings */)),
+ has(expr().bind("null_arg_expr")))
.bind("construct_expr");
+ // `std::string_view(null_arg_expr)`
auto HandleTemporaryCXXFunctionalCastExpr =
- makeRule(cxxFunctionalCastExpr(
- hasSourceExpression(StringViewConstructingFromNullExpr)),
- remove(node("null_argument_expr")), construction_warning);
+ makeRule(cxxFunctionalCastExpr(hasSourceExpression(
+ BasicStringViewConstructingFromNullExpr)),
+ remove(node("null_arg_expr")), construction_warning);
- auto HandleTemporaryCXXTemporaryObjectExprAndCompoundLiteralExpr =
- makeRule(cxxTemporaryObjectExpr(StringViewConstructingFromNullExpr),
- remove(node("null_argument_expr")), construction_warning);
+ // `std::string_view{null_arg_expr}` and `(std::string_view){null_arg_expr}`
+ auto HandleTemporaryCXXTemporaryObjectExprAndCompoundLiteralExpr = makeRule(
+ cxxTemporaryObjectExpr(cxxConstructExpr(
+ HasBasicStringViewType, argumentCountIs(1),
+ hasAnyArgument(/* `hasArgument` would skip over parens */ anyOf(
+ NullLiteral, NullInitList, EmptyInitList)),
+ has(expr().bind("null_arg_expr")))),
+ remove(node("null_arg_expr")), construction_warning);
+ // `(std::string_view) null_arg_expr`
auto HandleTemporaryCStyleCastExpr = makeRule(
- cStyleCastExpr(hasSourceExpression(StringViewConstructingFromNullExpr)),
- changeTo(node("null_argument_expr"), cat("{}")), construction_warning);
+ cStyleCastExpr(
+ hasSourceExpression(BasicStringViewConstructingFromNullExpr)),
+ changeTo(node("null_arg_expr"), cat("{}")), construction_warning);
+ // `static_cast<std::string_view>(null_arg_expr)`
auto HandleTemporaryCXXStaticCastExpr = makeRule(
cxxStaticCastExpr(
- hasSourceExpression(StringViewConstructingFromNullExpr)),
- changeTo(node("null_argument_expr"), cat("\"\"")), construction_warning);
+ hasSourceExpression(BasicStringViewConstructingFromNullExpr)),
+ changeTo(node("null_arg_expr"), cat("\"\"")), static_cast_warning);
+ // `std::string_view sv = null_arg_expr;`
auto HandleStackCopyInitialization = makeRule(
- varDecl(hasInitializer(implicitCastExpr(
- ignoringImpCasts(StringViewConstructingFromNullExpr)))),
- changeTo(node("null_argument_expr"), cat("{}")), construction_warning);
+ varDecl(HasBasicStringViewType,
+ hasInitializer(ignoringImpCasts(
+ cxxConstructExpr(BasicStringViewConstructingFromNullExpr,
+ unless(isListInitialization())))),
+ unless(isDirectInitialization())),
+ changeTo(node("null_arg_expr"), cat("{}")), construction_warning);
+ // `std::string_view sv = {null_arg_expr};`
+ auto HandleStackCopyListInitialization =
+ makeRule(varDecl(HasBasicStringViewType,
+ hasInitializer(cxxConstructExpr(
+ BasicStringViewConstructingFromNullExpr,
+ isListInitialization())),
+ unless(isDirectInitialization())),
+ remove(node("null_arg_expr")), construction_warning);
+
+ // `std::string_view sv(null_arg_expr);`
auto HandleStackDirectInitialization =
- makeRule(varDecl(hasInitializer(
- cxxConstructExpr(StringViewConstructingFromNullExpr,
- unless(isListInitialization()))))
+ makeRule(varDecl(HasBasicStringViewType,
+ hasInitializer(cxxConstructExpr(
+ BasicStringViewConstructingFromNullExpr,
+ unless(isListInitialization()))),
+ isDirectInitialization())
.bind("var_decl"),
changeTo(node("construct_expr"), cat(name("var_decl"))),
construction_warning);
- auto HandleStackDirectListAndCopyListInitialization = makeRule(
- varDecl(hasInitializer(cxxConstructExpr(
- StringViewConstructingFromNullExpr, isListInitialization()))),
- remove(node("null_argument_expr")), construction_warning);
+ // `std::string_view sv{null_arg_expr};`
+ auto HandleStackDirectListInitialization =
+ makeRule(varDecl(HasBasicStringViewType,
+ hasInitializer(cxxConstructExpr(
+ BasicStringViewConstructingFromNullExpr,
+ isListInitialization())),
+ isDirectInitialization()),
+ remove(node("null_arg_expr")), construction_warning);
- auto HandleFieldCopyInitialization = makeRule(
- fieldDecl(hasInClassInitializer(implicitCastExpr(
- ignoringImpCasts(StringViewConstructingFromNullExpr)))),
- changeTo(node("null_argument_expr"), cat("{}")), construction_warning);
+ // `struct S { std::string_view sv = null_arg_expr; };`
+ auto HandleFieldInClassCopyInitialization = makeRule(
+ fieldDecl(HasBasicStringViewType,
+ hasInClassInitializer(ignoringImpCasts(
+ cxxConstructExpr(BasicStringViewConstructingFromNullExpr,
+ unless(isListInitialization()))))),
+ changeTo(node("null_arg_expr"), cat("{}")), construction_warning);
- auto HandleFieldOtherInitialization = makeRule(
- fieldDecl(hasInClassInitializer(StringViewConstructingFromNullExpr)),
- remove(node("null_argument_expr")), construction_warning);
+ // `struct S { std::string_view sv = {null_arg_expr}; };` and
+ // `struct S { std::string_view sv{null_arg_expr}; };`
+ auto HandleFieldInClassCopyListAndDirectListInitialization = makeRule(
+ fieldDecl(HasBasicStringViewType,
+ hasInClassInitializer(ignoringImpCasts(
+ cxxConstructExpr(BasicStringViewConstructingFromNullExpr,
+ isListInitialization())))),
+ remove(node("null_arg_expr")), construction_warning);
- auto HandleConstructorInitialization = makeRule(
- cxxCtorInitializer(withInitializer(StringViewConstructingFromNullExpr)),
- remove(node("null_argument_expr")), construction_warning);
+ // `class C { std::string_view sv; C() : sv(null_arg_expr) {} };`
+ auto HandleConstructorDirectInitialization =
+ makeRule(cxxCtorInitializer(forField(fieldDecl(HasBasicStringViewType)),
+ withInitializer(cxxConstructExpr(
+ BasicStringViewConstructingFromNullExpr,
+ unless(isListInitialization())))),
+ remove(node("null_arg_expr")), construction_warning);
- auto HandleDefaultArgumentInitialization = makeRule(
- parmVarDecl(hasInitializer(implicitCastExpr(
- hasSourceExpression(StringViewConstructingFromNullExpr)))),
- changeTo(node("null_argument_expr"), cat("{}")), construction_warning);
+ // `class C { std::string_view sv; C() : sv{null_arg_expr} {} };`
+ auto HandleConstructorDirectListInitialization =
+ makeRule(cxxCtorInitializer(forField(fieldDecl(HasBasicStringViewType)),
+ withInitializer(cxxConstructExpr(
+ BasicStringViewConstructingFromNullExpr,
+ isListInitialization()))),
+ remove(node("null_arg_expr")), construction_warning);
- auto HandleDefaultArgumentListInitialization =
- makeRule(parmVarDecl(hasInitializer(StringViewConstructingFromNullExpr)),
- remove(node("null_argument_expr")), construction_warning);
+ // `void f(std::string_view sv = null_arg_expr);`
+ auto HandleDefaultArgumentCopyInitialization = makeRule(
+ parmVarDecl(HasBasicStringViewType,
+ hasInitializer(ignoringImpCasts(
+ cxxConstructExpr(BasicStringViewConstructingFromNullExpr,
+ unless(isListInitialization()))))),
+ changeTo(node("null_arg_expr"), cat("{}")), construction_warning);
- auto HandleHeapInitialization = makeRule(
- cxxNewExpr(unless(isArray()), has(StringViewConstructingFromNullExpr)),
- remove(node("null_argument_expr")), construction_warning);
+ // `void f(std::string_view sv = {null_arg_expr});`
+ auto HandleDefaultArgumentCopyListInitialization =
+ makeRule(parmVarDecl(HasBasicStringViewType,
+ hasInitializer(cxxConstructExpr(
+ BasicStringViewConstructingFromNullExpr,
+ isListInitialization()))),
+ remove(node("null_arg_expr")), construction_warning);
- auto HandleFunctionArgumentInitialization = makeRule(
- implicitCastExpr(hasSourceExpression(StringViewConstructingFromNullExpr),
- hasParent(callExpr(unless(cxxOperatorCallExpr())))),
- changeTo(node("null_argument_expr"), cat("{}")), construction_warning);
+ // `new std::string_view(null_arg_expr)`
+ auto HandleHeapDirectInitialization = makeRule(
+ cxxNewExpr(has(cxxConstructExpr(BasicStringViewConstructingFromNullExpr,
+ unless(isListInitialization()))),
+ unless(isArray()), unless(hasAnyPlacementArg(anything()))),
+ remove(node("null_arg_expr")), construction_warning);
- auto HandleFunctionArgumentListInitialization = makeRule(
- cxxConstructExpr(StringViewConstructingFromNullExpr,
- hasParent(callExpr(unless(cxxOperatorCallExpr())))),
- remove(node("null_argument_expr")), construction_warning);
+ // `new std::string_view{null_arg_expr}`
+ auto HandleHeapDirectListInitialization = makeRule(
+ cxxNewExpr(has(cxxConstructExpr(BasicStringViewConstructingFromNullExpr,
+ isListInitialization())),
+ unless(isArray()), unless(hasAnyPlacementArg(anything()))),
+ remove(node("null_arg_expr")), construction_warning);
+ // `function(null_arg_expr)`
+ auto HandleFunctionArgumentInitialization = makeRule(
+ callExpr(hasAnyArgument(
+ ignoringImpCasts(BasicStringViewConstructingFromNullExpr)),
+ unless(cxxOperatorCallExpr())),
+ changeTo(node("construct_expr"), cat("{}")), construction_warning);
+
+ // `sv = null_arg_expr`
auto HandleAssignment = makeRule(
- materializeTemporaryExpr(
- has(StringViewConstructingFromNullExpr),
- hasParent(cxxOperatorCallExpr(hasOverloadedOperatorName("=")))),
+ cxxOperatorCallExpr(hasOverloadedOperatorName("="),
+ hasRHS(materializeTemporaryExpr(
+ has(BasicStringViewConstructingFromNullExpr)))),
changeTo(node("construct_expr"), cat("{}")), assignment_warning);
- auto HandleRelativeComparison =
- makeRule(implicitCastExpr(
- hasSourceExpression(StringViewConstructingFromNullExpr),
- hasParent(cxxOperatorCallExpr(
- hasAnyOverloadedOperatorName("<", "<=", ">", ">=")))),
- changeTo(node("null_argument_expr"), cat("\"\"")),
- relative_comparison_warning);
+ // `sv < null_arg_expr`
+ auto HandleRelativeComparison = makeRule(
+ cxxOperatorCallExpr(hasAnyOverloadedOperatorName("<", "<=", ">", ">="),
+ hasEitherOperand(ignoringImpCasts(
+ BasicStringViewConstructingFromNullExpr))),
+ changeTo(node("construct_expr"), cat("\"\"")),
+ relative_comparison_warning);
+ // `sv == null_arg_expr`
auto HandleEmptyEqualityComparison = makeRule(
cxxOperatorCallExpr(
hasOverloadedOperatorName("=="),
- hasOperands(traverse(clang::TK_IgnoreUnlessSpelledInSource,
- expr().bind("string_view_instance")),
- implicitCastExpr(hasSourceExpression(
- StringViewConstructingFromNullExpr))))
+ hasOperands(ignoringImpCasts(BasicStringViewConstructingFromNullExpr),
+ traverse(clang::TK_IgnoreUnlessSpelledInSource,
+ expr().bind("instance"))))
.bind("root"),
- changeTo(node("root"),
- cat(access("string_view_instance", cat("empty")), "()")),
+ changeTo(node("root"), cat(access("instance", cat("empty")), "()")),
equality_comparison_warning);
+ // `sv != null_arg_expr`
auto HandleNonEmptyEqualityComparison = makeRule(
cxxOperatorCallExpr(
hasOverloadedOperatorName("!="),
- hasOperands(traverse(clang::TK_IgnoreUnlessSpelledInSource,
- expr().bind("string_view_instance")),
- implicitCastExpr(hasSourceExpression(
- StringViewConstructingFromNullExpr))))
+ hasOperands(ignoringImpCasts(BasicStringViewConstructingFromNullExpr),
+ traverse(clang::TK_IgnoreUnlessSpelledInSource,
+ expr().bind("instance"))))
.bind("root"),
- changeTo(node("root"),
- cat("!", access("string_view_instance", cat("empty")), "()")),
+ changeTo(node("root"), cat("!", access("instance", cat("empty")), "()")),
equality_comparison_warning);
+ // `return null_arg_expr;`
+ auto HandleReturnStatement = makeRule(
+ returnStmt(hasReturnValue(
+ ignoringImpCasts(BasicStringViewConstructingFromNullExpr))),
+ changeTo(node("construct_expr"), cat("{}")), construction_warning);
+
+ // `T(null_arg_expr)`
+ auto HandleConstructorInvocation =
+ makeRule(cxxConstructExpr(
+ hasAnyArgument(/* `hasArgument` would skip over parens */
+ ignoringImpCasts(
+ BasicStringViewConstructingFromNullExpr)),
+ unless(HasBasicStringViewType)),
+ changeTo(node("construct_expr"), cat("\"\"")),
+ constructor_argument_warning);
+
return applyFirst(
{HandleTemporaryCXXFunctionalCastExpr,
HandleTemporaryCXXTemporaryObjectExprAndCompoundLiteralExpr,
- HandleTemporaryCStyleCastExpr, HandleTemporaryCXXStaticCastExpr,
- HandleStackCopyInitialization, HandleStackDirectInitialization,
- HandleStackDirectListAndCopyListInitialization,
- HandleFieldCopyInitialization, HandleFieldOtherInitialization,
- HandleConstructorInitialization, HandleDefaultArgumentInitialization,
- HandleDefaultArgumentListInitialization, HandleHeapInitialization,
+ HandleTemporaryCStyleCastExpr,
+ HandleTemporaryCXXStaticCastExpr,
+ HandleStackCopyInitialization,
+ HandleStackCopyListInitialization,
+ HandleStackDirectInitialization,
+ HandleStackDirectListInitialization,
+ HandleFieldInClassCopyInitialization,
+ HandleFieldInClassCopyListAndDirectListInitialization,
+ HandleConstructorDirectInitialization,
+ HandleConstructorDirectListInitialization,
+ HandleDefaultArgumentCopyInitialization,
+ HandleDefaultArgumentCopyListInitialization,
+ HandleHeapDirectInitialization,
+ HandleHeapDirectListInitialization,
HandleFunctionArgumentInitialization,
- HandleFunctionArgumentListInitialization, HandleAssignment,
- HandleRelativeComparison, HandleEmptyEqualityComparison,
- HandleNonEmptyEqualityComparison});
+ HandleAssignment,
+ HandleRelativeComparison,
+ HandleEmptyEqualityComparison,
+ HandleNonEmptyEqualityComparison,
+ HandleReturnStatement,
+ HandleConstructorInvocation});
}
StringviewNullptrCheck::StringviewNullptrCheck(StringRef Name,
diff --git a/clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp b/clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp
index d6668f1727960..322c8eeca754e 100644
--- a/clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp
+++ b/clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp
@@ -16,78 +16,116 @@ using type_identity_t = typename type_identity<T>::type;
template <typename CharT>
class basic_string_view {
public:
- basic_string_view();
+ constexpr basic_string_view() {}
- basic_string_view(const CharT *);
+ constexpr basic_string_view(const CharT *) {}
// Not present in C++17 and C++20:
- // basic_string_view(std::nullptr_t);
+ // constexpr basic_string_view(std::nullptr_t) {}
- basic_string_view(const CharT *, size_t);
+ constexpr basic_string_view(const CharT *, size_t) {}
- basic_string_view(const basic_string_view &);
+ constexpr basic_string_view(const basic_string_view &) {}
- basic_string_view &operator=(const basic_string_view &);
+ constexpr basic_string_view &operator=(const basic_string_view &) {}
};
template <typename CharT>
-bool operator<(basic_string_view<CharT>, basic_string_view<CharT>);
+constexpr bool operator<(basic_string_view<CharT>, basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator<(type_identity_t<basic_string_view<CharT>>,
- basic_string_view<CharT>);
+constexpr bool operator<(type_identity_t<basic_string_view<CharT>>,
+ basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator<(basic_string_view<CharT>,
- type_identity_t<basic_string_view<CharT>>);
+constexpr bool operator<(basic_string_view<CharT>,
+ type_identity_t<basic_string_view<CharT>>) {
+ return {};
+}
template <typename CharT>
-bool operator<=(basic_string_view<CharT>, basic_string_view<CharT>);
+constexpr bool operator<=(basic_string_view<CharT>, basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator<=(type_identity_t<basic_string_view<CharT>>,
- basic_string_view<CharT>);
+constexpr bool operator<=(type_identity_t<basic_string_view<CharT>>,
+ basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator<=(basic_string_view<CharT>,
- type_identity_t<basic_string_view<CharT>>);
+constexpr bool operator<=(basic_string_view<CharT>,
+ type_identity_t<basic_string_view<CharT>>) {
+ return {};
+}
template <typename CharT>
-bool operator>(basic_string_view<CharT>, basic_string_view<CharT>);
+constexpr bool operator>(basic_string_view<CharT>, basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator>(type_identity_t<basic_string_view<CharT>>,
- basic_string_view<CharT>);
+constexpr bool operator>(type_identity_t<basic_string_view<CharT>>,
+ basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator>(basic_string_view<CharT>,
- type_identity_t<basic_string_view<CharT>>);
+constexpr bool operator>(basic_string_view<CharT>,
+ type_identity_t<basic_string_view<CharT>>) {
+ return {};
+}
template <typename CharT>
-bool operator>=(basic_string_view<CharT>, basic_string_view<CharT>);
+constexpr bool operator>=(basic_string_view<CharT>, basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator>=(type_identity_t<basic_string_view<CharT>>,
- basic_string_view<CharT>);
+constexpr bool operator>=(type_identity_t<basic_string_view<CharT>>,
+ basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator>=(basic_string_view<CharT>,
- type_identity_t<basic_string_view<CharT>>);
+constexpr bool operator>=(basic_string_view<CharT>,
+ type_identity_t<basic_string_view<CharT>>) {
+ return {};
+}
template <typename CharT>
-bool operator==(basic_string_view<CharT>, basic_string_view<CharT>);
+constexpr bool operator==(basic_string_view<CharT>, basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator==(type_identity_t<basic_string_view<CharT>>,
- basic_string_view<CharT>);
+constexpr bool operator==(type_identity_t<basic_string_view<CharT>>,
+ basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator==(basic_string_view<CharT>,
- type_identity_t<basic_string_view<CharT>>);
+constexpr bool operator==(basic_string_view<CharT>,
+ type_identity_t<basic_string_view<CharT>>) {
+ return {};
+}
template <typename CharT>
-bool operator!=(basic_string_view<CharT>, basic_string_view<CharT>);
+constexpr bool operator!=(basic_string_view<CharT>, basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator!=(type_identity_t<basic_string_view<CharT>>,
- basic_string_view<CharT>);
+constexpr bool operator!=(type_identity_t<basic_string_view<CharT>>,
+ basic_string_view<CharT>) {
+ return {};
+}
template <typename CharT>
-bool operator!=(basic_string_view<CharT>,
- type_identity_t<basic_string_view<CharT>>);
+constexpr bool operator!=(basic_string_view<CharT>,
+ type_identity_t<basic_string_view<CharT>>) {
+ return {};
+}
using string_view = basic_string_view<char>;
} // namespace std
+using SV = std::string_view; // Used in some places for shorter line length
+
void function(std::string_view);
void function(std::string_view, std::string_view);
@@ -200,19 +238,19 @@ void temporary_construction() /* a */ {
// Static Cast
{
(void)(static_cast<std::string_view>(nullptr)) /* a25 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: constructing{{.*}}default
+ // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: casting to basic_string_view from null is undefined; replace with the empty string
// CHECK-FIXES: {{^}} (void)(static_cast<std::string_view>("")) /* a25 */;
(void)(static_cast<std::string_view>((nullptr))) /* a26 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: constructing{{.*}}default
+ // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: casting{{.*}}empty string
// CHECK-FIXES: {{^}} (void)(static_cast<std::string_view>("")) /* a26 */;
(void)(static_cast<const std::string_view>(nullptr)) /* a27 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing{{.*}}default
+ // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: casting{{.*}}empty string
// CHECK-FIXES: {{^}} (void)(static_cast<const std::string_view>("")) /* a27 */;
(void)(static_cast<const std::string_view>((nullptr))) /* a28 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing{{.*}}default
+ // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: casting{{.*}}empty string
// CHECK-FIXES: {{^}} (void)(static_cast<const std::string_view>("")) /* a28 */;
}
}
@@ -237,140 +275,232 @@ void stack_construction() /* b */ {
// CHECK-FIXES: {{^}} const std::string_view b4 = {};
}
+ // Copy Initialization With Temporary
+ {
+ std::string_view b5 = std::string_view(nullptr);
+ // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b5 = std::string_view();
+
+ std::string_view b6 = std::string_view{nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b6 = std::string_view{};
+
+ std::string_view b7 = (std::string_view) nullptr;
+ // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b7 = (std::string_view) {};
+
+ std::string_view b8 = (std::string_view){nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b8 = (std::string_view){};
+
+ std::string_view b9 = static_cast<SV>(nullptr);
+ // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} std::string_view b9 = static_cast<SV>("");
+ }
+
// Copy List Initialization
{
- std::string_view b5 = {nullptr};
- // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b5 = {};
+ std::string_view b10 = {nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b10 = {};
- std::string_view b6 = {(nullptr)};
- // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b6 = {};
+ std::string_view b11 = {(nullptr)};
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b11 = {};
- std::string_view b7 = {{nullptr}};
- // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b7 = {};
+ std::string_view b12 = {{nullptr}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b12 = {};
- std::string_view b8 = {{(nullptr)}};
- // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b8 = {};
+ std::string_view b13 = {{(nullptr)}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b13 = {};
- std::string_view b9 = {{}}; // Default `const CharT*`
- // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b9 = {};
+ std::string_view b14 = {{}}; // Default `const CharT*`
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b14 = {};
- const std::string_view b10 = {nullptr};
+ const std::string_view b15 = {nullptr};
// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b10 = {};
+ // CHECK-FIXES: {{^}} const std::string_view b15 = {};
- const std::string_view b11 = {(nullptr)};
+ const std::string_view b16 = {(nullptr)};
// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b11 = {};
+ // CHECK-FIXES: {{^}} const std::string_view b16 = {};
- const std::string_view b12 = {{nullptr}};
+ const std::string_view b17 = {{nullptr}};
// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b12 = {};
+ // CHECK-FIXES: {{^}} const std::string_view b17 = {};
- const std::string_view b13 = {{(nullptr)}};
+ const std::string_view b18 = {{(nullptr)}};
// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b13 = {};
+ // CHECK-FIXES: {{^}} const std::string_view b18 = {};
- const std::string_view b14 = {{}}; // Default `const CharT*`
+ const std::string_view b19 = {{}}; // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b14 = {};
+ // CHECK-FIXES: {{^}} const std::string_view b19 = {};
+ }
+
+ // Copy List Initialization With Temporary
+ {
+ std::string_view b20 = {std::string_view(nullptr)};
+ // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b20 = {std::string_view()};
+
+ std::string_view b21 = {std::string_view{nullptr}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b21 = {std::string_view{}};
+
+ std::string_view b22 = {(std::string_view) nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b22 = {(std::string_view) {}};
+
+ std::string_view b23 = {(std::string_view){nullptr}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b23 = {(std::string_view){}};
+
+ std::string_view b24 = {static_cast<SV>(nullptr)};
+ // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} std::string_view b24 = {static_cast<SV>("")};
}
// Direct Initialization
{
- std::string_view b15(nullptr);
+ std::string_view b25(nullptr);
// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b15;
+ // CHECK-FIXES: {{^}} std::string_view b25;
- std::string_view b16((nullptr));
+ std::string_view b26((nullptr));
// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b16;
+ // CHECK-FIXES: {{^}} std::string_view b26;
- std::string_view b17({nullptr});
+ std::string_view b27({nullptr});
// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b17;
+ // CHECK-FIXES: {{^}} std::string_view b27;
- std::string_view b18({(nullptr)});
+ std::string_view b28({(nullptr)});
// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b18;
+ // CHECK-FIXES: {{^}} std::string_view b28;
- std::string_view b19({}); // Default `const CharT*`
+ std::string_view b29({}); // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b19;
+ // CHECK-FIXES: {{^}} std::string_view b29;
- const std::string_view b20(nullptr);
+ const std::string_view b30(nullptr);
// CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b20;
+ // CHECK-FIXES: {{^}} const std::string_view b30;
- const std::string_view b21((nullptr));
+ const std::string_view b31((nullptr));
// CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b21;
+ // CHECK-FIXES: {{^}} const std::string_view b31;
- const std::string_view b22({nullptr});
+ const std::string_view b32({nullptr});
// CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b22;
+ // CHECK-FIXES: {{^}} const std::string_view b32;
- const std::string_view b23({(nullptr)});
+ const std::string_view b33({(nullptr)});
// CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b23;
+ // CHECK-FIXES: {{^}} const std::string_view b33;
- const std::string_view b24({}); // Default `const CharT*`
+ const std::string_view b34({}); // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b24;
+ // CHECK-FIXES: {{^}} const std::string_view b34;
+ }
+
+ // Direct Initialization With Temporary
+ {
+ std::string_view b35(std::string_view(nullptr));
+ // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b35(std::string_view());
+
+ std::string_view b36(std::string_view{nullptr});
+ // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b36(std::string_view{});
+
+ std::string_view b37((std::string_view) nullptr);
+ // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b37((std::string_view) {});
+
+ std::string_view b38((std::string_view){nullptr});
+ // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b38((std::string_view){});
+
+ std::string_view b39(static_cast<SV>(nullptr));
+ // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} std::string_view b39(static_cast<SV>(""));
}
// Direct List Initialization
{
- std::string_view b25{nullptr};
+ std::string_view b40{nullptr};
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b25{};
+ // CHECK-FIXES: {{^}} std::string_view b40{};
- std::string_view b26{(nullptr)};
+ std::string_view b41{(nullptr)};
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b26{};
+ // CHECK-FIXES: {{^}} std::string_view b41{};
- std::string_view b27{{nullptr}};
+ std::string_view b42{{nullptr}};
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b27{};
+ // CHECK-FIXES: {{^}} std::string_view b42{};
- std::string_view b28{{(nullptr)}};
+ std::string_view b43{{(nullptr)}};
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b28{};
+ // CHECK-FIXES: {{^}} std::string_view b43{};
- std::string_view b29{{}}; // Default `const CharT*`
+ std::string_view b44{{}}; // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view b29{};
+ // CHECK-FIXES: {{^}} std::string_view b44{};
- const std::string_view b30{nullptr};
+ const std::string_view b45{nullptr};
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b30{};
+ // CHECK-FIXES: {{^}} const std::string_view b45{};
- const std::string_view b31{(nullptr)};
+ const std::string_view b46{(nullptr)};
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b31{};
+ // CHECK-FIXES: {{^}} const std::string_view b46{};
- const std::string_view b32{{nullptr}};
+ const std::string_view b47{{nullptr}};
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b32{};
+ // CHECK-FIXES: {{^}} const std::string_view b47{};
- const std::string_view b33{{(nullptr)}};
+ const std::string_view b48{{(nullptr)}};
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b33{};
+ // CHECK-FIXES: {{^}} const std::string_view b48{};
- const std::string_view b34{{}}; // Default `const CharT*`
+ const std::string_view b49{{}}; // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view b34{};
+ // CHECK-FIXES: {{^}} const std::string_view b49{};
+ }
+
+ // Direct List Initialization With Temporary
+ {
+ std::string_view b50{std::string_view(nullptr)};
+ // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b50{std::string_view()};
+
+ std::string_view b51{std::string_view{nullptr}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b51{std::string_view{}};
+
+ std::string_view b52{(std::string_view) nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b52{(std::string_view) {}};
+
+ std::string_view b53{(std::string_view){nullptr}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view b53{(std::string_view){}};
+
+ std::string_view b54{static_cast<SV>(nullptr)};
+ // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} std::string_view b54{static_cast<SV>("")};
}
}
void field_construction() /* c */ {
- struct DefaultMemberInitializers {
- void CopyInitialization();
+ // Default Member Initializaers
+ struct DMICopyInitialization {
std::string_view c1 = nullptr;
// CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing{{.*}}default
// CHECK-FIXES: {{^}} std::string_view c1 = {};
@@ -386,153 +516,278 @@ void field_construction() /* c */ {
const std::string_view c4 = (nullptr);
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default
// CHECK-FIXES: {{^}} const std::string_view c4 = {};
+ };
- void CopyListInitialization();
+ struct DMICopyInitializationWithTemporary {
+ std::string_view c5 = std::string_view(nullptr);
+ // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c5 = std::string_view();
- std::string_view c5 = {nullptr};
- // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view c5 = {};
+ std::string_view c6 = std::string_view{nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c6 = std::string_view{};
- std::string_view c6 = {(nullptr)};
- // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view c6 = {};
+ std::string_view c7 = (std::string_view) nullptr;
+ // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c7 = (std::string_view) {};
- std::string_view c7 = {{nullptr}};
- // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view c7 = {};
+ std::string_view c8 = (std::string_view){nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c8 = (std::string_view){};
- std::string_view c8 = {{(nullptr)}};
- // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view c8 = {};
+ std::string_view c9 = static_cast<SV>(nullptr);
+ // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} std::string_view c9 = static_cast<SV>("");
+ };
- std::string_view c9 = {{}}; // Default `const CharT*`
- // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view c9 = {};
+ struct DMICopyListInitialization {
+ std::string_view c10 = {nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c10 = {};
+
+ std::string_view c11 = {(nullptr)};
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c11 = {};
+
+ std::string_view c12 = {{nullptr}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c12 = {};
+
+ std::string_view c13 = {{(nullptr)}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c13 = {};
+
+ std::string_view c14 = {{}}; // Default `const CharT*`
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c14 = {};
- const std::string_view c10 = {nullptr};
+ const std::string_view c15 = {nullptr};
// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view c10 = {};
+ // CHECK-FIXES: {{^}} const std::string_view c15 = {};
- const std::string_view c11 = {(nullptr)};
+ const std::string_view c16 = {(nullptr)};
// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view c11 = {};
+ // CHECK-FIXES: {{^}} const std::string_view c16 = {};
- const std::string_view c12 = {{nullptr}};
+ const std::string_view c17 = {{nullptr}};
// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view c12 = {};
+ // CHECK-FIXES: {{^}} const std::string_view c17 = {};
- const std::string_view c13 = {{(nullptr)}};
+ const std::string_view c18 = {{(nullptr)}};
// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view c13 = {};
+ // CHECK-FIXES: {{^}} const std::string_view c18 = {};
- const std::string_view c14 = {{}}; // Default `const CharT*`
+ const std::string_view c19 = {{}}; // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view c14 = {};
+ // CHECK-FIXES: {{^}} const std::string_view c19 = {};
+ };
+
+ struct DMICopyListInitializationWithTemporary {
+ std::string_view c20 = {std::string_view(nullptr)};
+ // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c20 = {std::string_view()};
+
+ std::string_view c21 = {std::string_view{nullptr}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:46: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c21 = {std::string_view{}};
+
+ std::string_view c22 = {(std::string_view) nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c22 = {(std::string_view) {}};
+
+ std::string_view c23 = {(std::string_view){nullptr}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c23 = {(std::string_view){}};
- void DirectListInitialization();
+ std::string_view c24 = {static_cast<SV>(nullptr)};
+ // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} std::string_view c24 = {static_cast<SV>("")};
+ };
- std::string_view c15{nullptr};
+ struct DMIDirectListInitialization {
+ std::string_view c25{nullptr};
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view c15{};
+ // CHECK-FIXES: {{^}} std::string_view c25{};
- std::string_view c16{(nullptr)};
+ std::string_view c26{(nullptr)};
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view c16{};
+ // CHECK-FIXES: {{^}} std::string_view c26{};
- std::string_view c17{{nullptr}};
+ std::string_view c27{{nullptr}};
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view c17{};
+ // CHECK-FIXES: {{^}} std::string_view c27{};
- std::string_view c18{{(nullptr)}};
+ std::string_view c28{{(nullptr)}};
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view c18{};
+ // CHECK-FIXES: {{^}} std::string_view c28{};
- std::string_view c19{{}}; // Default `const CharT*`
+ std::string_view c29{{}}; // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} std::string_view c19{};
+ // CHECK-FIXES: {{^}} std::string_view c29{};
- const std::string_view c20{nullptr};
+ const std::string_view c30{nullptr};
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view c20{};
+ // CHECK-FIXES: {{^}} const std::string_view c30{};
- const std::string_view c21{(nullptr)};
+ const std::string_view c31{(nullptr)};
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view c21{};
+ // CHECK-FIXES: {{^}} const std::string_view c31{};
- const std::string_view c22{{nullptr}};
+ const std::string_view c32{{nullptr}};
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view c22{};
+ // CHECK-FIXES: {{^}} const std::string_view c32{};
- const std::string_view c23{{(nullptr)}};
+ const std::string_view c33{{(nullptr)}};
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view c23{};
+ // CHECK-FIXES: {{^}} const std::string_view c33{};
- const std::string_view c24{{}}; // Default `const CharT*`
+ const std::string_view c34{{}}; // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} const std::string_view c24{};
+ // CHECK-FIXES: {{^}} const std::string_view c34{};
};
- class ConstructorInitializers {
- ConstructorInitializers()
- : direct_initialization(),
+ struct DMIDirectListInitializationWithTemporary {
+ std::string_view c35{std::string_view(nullptr)};
+ // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c35{std::string_view()};
- c25(nullptr),
- // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} c25(),
+ std::string_view c36{std::string_view{nullptr}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c36{std::string_view{}};
- c26((nullptr)),
+ std::string_view c37{(std::string_view) nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c37{(std::string_view) {}};
+
+ std::string_view c38{(std::string_view){nullptr}};
+ // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} std::string_view c38{(std::string_view){}};
+
+ std::string_view c39{static_cast<SV>(nullptr)};
+ // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} std::string_view c39{static_cast<SV>("")};
+ };
+
+ // Constructor Initializers
+
+ class CIDirectInitialization {
+ std::string_view c40;
+ std::string_view c41;
+ std::string_view c42;
+ std::string_view c43;
+ std::string_view c44;
+
+ CIDirectInitialization()
+ : c40(nullptr),
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} c26(),
+ // CHECK-FIXES: {{^}} : c40(),
- c27({nullptr}),
+ c41((nullptr)),
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} c27(),
+ // CHECK-FIXES: {{^}} c41(),
- c28({(nullptr)}),
+ c42({nullptr}),
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} c28(),
+ // CHECK-FIXES: {{^}} c42(),
- c29({}), // Default `const CharT*`
+ c43({(nullptr)}),
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} c29(),
+ // CHECK-FIXES: {{^}} c43(),
- direct_list_initialization(),
+ c44({}) { // Default `const CharT*`
+ // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} c44() {
+ }
+ };
- c30{nullptr},
- // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} c30{},
+ class CIDirectInitializationWithTemporary {
+ std::string_view c45;
+ std::string_view c46;
+ std::string_view c47;
+ std::string_view c48;
+ std::string_view c49;
+
+ CIDirectInitializationWithTemporary()
+ : c45(std::string_view(nullptr)),
+ // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} : c45(std::string_view()),
+
+ c46(std::string_view{nullptr}),
+ // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} c46(std::string_view{}),
+
+ c47((std::string_view) nullptr),
+ // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} c47((std::string_view) {}),
+
+ c48((std::string_view){nullptr}),
+ // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} c48((std::string_view){}),
+
+ c49(static_cast<SV>(nullptr)) {
+ // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} c49(static_cast<SV>("")) {
+ }
+ };
+
+ class CIDirectListInitialization {
+ std::string_view c50;
+ std::string_view c51;
+ std::string_view c52;
+ std::string_view c53;
+ std::string_view c54;
- c31{(nullptr)},
+ CIDirectListInitialization()
+ : c50{nullptr},
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} c31{},
+ // CHECK-FIXES: {{^}} : c50{},
- c32{{nullptr}},
+ c51{(nullptr)},
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} c32{},
+ // CHECK-FIXES: {{^}} c51{},
- c33{{(nullptr)}},
+ c52{{nullptr}},
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} c33{},
+ // CHECK-FIXES: {{^}} c52{},
- c34{{}}, // Default `const CharT*`
+ c53{{(nullptr)}},
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} c34{},
-
- end_of_list() {}
-
- std::nullptr_t direct_initialization;
- std::string_view c25;
- std::string_view c26;
- std::string_view c27;
- std::string_view c28;
- std::string_view c29;
- std::nullptr_t direct_list_initialization;
- std::string_view c30;
- std::string_view c31;
- std::string_view c32;
- std::string_view c33;
- std::string_view c34;
- std::nullptr_t end_of_list;
+ // CHECK-FIXES: {{^}} c53{},
+
+ c54{{}} { // Default `const CharT*`
+ // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} c54{} {
+ }
+ };
+
+ class CIDirectListInitializationWithTemporary {
+ std::string_view c55;
+ std::string_view c56;
+ std::string_view c57;
+ std::string_view c58;
+ std::string_view c59;
+
+ CIDirectListInitializationWithTemporary()
+ : c55{std::string_view(nullptr)},
+ // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} : c55{std::string_view()},
+
+ c56{std::string_view{nullptr}},
+ // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} c56{std::string_view{}},
+
+ c57{(std::string_view) nullptr},
+ // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} c57{(std::string_view) {}},
+
+ c58{(std::string_view){nullptr}},
+ // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} c58{(std::string_view){}},
+
+ c59{static_cast<SV>(nullptr)} {
+ // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} c59{static_cast<SV>("")} {
+ }
};
}
@@ -556,47 +811,93 @@ void default_argument_construction() /* d */ {
// CHECK-FIXES: {{^}} void d4(const std::string_view sv = {});
}
+ // Copy Initialization With Temporary
+ {
+ void d5(std::string_view sv = std::string_view(nullptr));
+ // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d5(std::string_view sv = std::string_view());
+
+ void d6(std::string_view sv = std::string_view{nullptr});
+ // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d6(std::string_view sv = std::string_view{});
+
+ void d7(std::string_view sv = (std::string_view) nullptr);
+ // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d7(std::string_view sv = (std::string_view) {});
+
+ void d8(std::string_view sv = (std::string_view){nullptr});
+ // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d8(std::string_view sv = (std::string_view){});
+
+ void d9(std::string_view sv = static_cast<SV>(nullptr));
+ // CHECK-MESSAGES: :[[@LINE-1]]:51: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} void d9(std::string_view sv = static_cast<SV>(""));
+ }
+
// Copy List Initialization
{
- void d5(std::string_view sv = {nullptr});
- // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} void d5(std::string_view sv = {});
+ void d10(std::string_view sv = {nullptr});
+ // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d10(std::string_view sv = {});
- void d6(std::string_view sv = {(nullptr)});
- // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} void d6(std::string_view sv = {});
+ void d11(std::string_view sv = {(nullptr)});
+ // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d11(std::string_view sv = {});
- void d7(std::string_view sv = {{nullptr}});
- // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} void d7(std::string_view sv = {});
+ void d12(std::string_view sv = {{nullptr}});
+ // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d12(std::string_view sv = {});
- void d8(std::string_view sv = {{(nullptr)}});
- // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} void d8(std::string_view sv = {});
+ void d13(std::string_view sv = {{(nullptr)}});
+ // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d13(std::string_view sv = {});
- void d9(std::string_view sv = {{}}); // Default `const CharT*`
- // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} void d9(std::string_view sv = {});
+ void d14(std::string_view sv = {{}}); // Default `const CharT*`
+ // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d14(std::string_view sv = {});
- void d10(const std::string_view sv = {nullptr});
+ void d15(const std::string_view sv = {nullptr});
// CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} void d10(const std::string_view sv = {});
+ // CHECK-FIXES: {{^}} void d15(const std::string_view sv = {});
- void d11(const std::string_view sv = {(nullptr)});
+ void d16(const std::string_view sv = {(nullptr)});
// CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} void d11(const std::string_view sv = {});
+ // CHECK-FIXES: {{^}} void d16(const std::string_view sv = {});
- void d12(const std::string_view sv = {{nullptr}});
+ void d17(const std::string_view sv = {{nullptr}});
// CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} void d12(const std::string_view sv = {});
+ // CHECK-FIXES: {{^}} void d17(const std::string_view sv = {});
- void d13(const std::string_view sv = {{(nullptr)}});
+ void d18(const std::string_view sv = {{(nullptr)}});
// CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} void d13(const std::string_view sv = {});
+ // CHECK-FIXES: {{^}} void d18(const std::string_view sv = {});
- void d14(const std::string_view sv = {{}}); // Default `const CharT*`
+ void d19(const std::string_view sv = {{}}); // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:43: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} void d14(const std::string_view sv = {});
+ // CHECK-FIXES: {{^}} void d19(const std::string_view sv = {});
+ }
+
+ // Copy List Initialization With Temporary
+ {
+ void d20(std::string_view sv = {std::string_view(nullptr)});
+ // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d20(std::string_view sv = {std::string_view()});
+
+ void d21(std::string_view sv = {std::string_view{nullptr}});
+ // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d21(std::string_view sv = {std::string_view{}});
+
+ void d22(std::string_view sv = {(std::string_view) nullptr});
+ // CHECK-MESSAGES: :[[@LINE-1]]:56: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d22(std::string_view sv = {(std::string_view) {}});
+
+ void d23(std::string_view sv = {(std::string_view){nullptr}});
+ // CHECK-MESSAGES: :[[@LINE-1]]:56: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} void d23(std::string_view sv = {(std::string_view){}});
+
+ void d24(std::string_view sv = {static_cast<SV>(nullptr)});
+ // CHECK-MESSAGES: :[[@LINE-1]]:53: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} void d24(std::string_view sv = {static_cast<SV>("")});
}
}
@@ -644,52 +945,98 @@ void heap_construction() /* e */ {
// CHECK-FIXES: {{^}} (void)(new const std::string_view()) /* e10 */;
}
+ // Direct Initialization With Temporary
+ {
+ (void)(new std::string_view(std::string_view(nullptr))) /* e11 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:50: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(new std::string_view(std::string_view())) /* e11 */;
+
+ (void)(new std::string_view(std::string_view{nullptr})) /* e12 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:50: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(new std::string_view(std::string_view{})) /* e12 */;
+
+ (void)(new std::string_view((std::string_view) nullptr)) /* e13 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(new std::string_view((std::string_view) {})) /* e13 */;
+
+ (void)(new std::string_view((std::string_view){nullptr})) /* e14 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(new std::string_view((std::string_view){})) /* e14 */;
+
+ (void)(new std::string_view(static_cast<SV>(nullptr))) /* e15 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} (void)(new std::string_view(static_cast<SV>(""))) /* e15 */;
+ }
+
// Direct List Initialization
{
- (void)(new std::string_view{nullptr}) /* e11 */;
+ (void)(new std::string_view{nullptr}) /* e16 */;
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e11 */;
+ // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e16 */;
- (void)(new std::string_view{(nullptr)}) /* e12 */;
+ (void)(new std::string_view{(nullptr)}) /* e17 */;
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e12 */;
+ // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e17 */;
- (void)(new std::string_view{{nullptr}}) /* e13 */;
+ (void)(new std::string_view{{nullptr}}) /* e18 */;
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e13 */;
+ // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e18 */;
- (void)(new std::string_view{{(nullptr)}}) /* e14 */;
+ (void)(new std::string_view{{(nullptr)}}) /* e19 */;
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e14 */;
+ // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e19 */;
- (void)(new std::string_view{{}}) /* e15 */; // Default `const CharT*`
+ (void)(new std::string_view{{}}) /* e20 */; // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e15 */;
+ // CHECK-FIXES: {{^}} (void)(new std::string_view{}) /* e20 */;
- (void)(new const std::string_view{nullptr}) /* e16 */;
+ (void)(new const std::string_view{nullptr}) /* e21 */;
// CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e16 */;
+ // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e21 */;
- (void)(new const std::string_view{(nullptr)}) /* e17 */;
+ (void)(new const std::string_view{(nullptr)}) /* e22 */;
// CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e17 */;
+ // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e22 */;
- (void)(new const std::string_view{{nullptr}}) /* e18 */;
+ (void)(new const std::string_view{{nullptr}}) /* e23 */;
// CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e18 */;
+ // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e23 */;
- (void)(new const std::string_view{{(nullptr)}}) /* e19 */;
+ (void)(new const std::string_view{{(nullptr)}}) /* e24 */;
// CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e19 */;
+ // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e24 */;
- (void)(new const std::string_view{{}}) /* e20 */; // Default `const CharT*`
+ (void)(new const std::string_view{{}}) /* e25 */; // Default `const CharT*`
// CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e20 */;
+ // CHECK-FIXES: {{^}} (void)(new const std::string_view{}) /* e25 */;
+ }
+
+ // Direct List Initialization With Temporary
+ {
+ (void)(new std::string_view{std::string_view(nullptr)}) /* e26 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:50: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(new std::string_view{std::string_view()}) /* e26 */;
+
+ (void)(new std::string_view{std::string_view{nullptr}}) /* e27 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:50: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(new std::string_view{std::string_view{}}) /* e27 */;
+
+ (void)(new std::string_view{(std::string_view) nullptr}) /* e28 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(new std::string_view{(std::string_view) {}}) /* e28 */;
+
+ (void)(new std::string_view{(std::string_view){nullptr}}) /* e29 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(new std::string_view{(std::string_view){}}) /* e29 */;
+
+ (void)(new std::string_view{static_cast<SV>(nullptr)}) /* e30 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} (void)(new std::string_view{static_cast<SV>("")}) /* e30 */;
}
}
-void function_invocation() /* f */ {
- // Single Argument
+void function_argument_initialization() /* f */ {
+ // Function Argument Initialization
{
function(nullptr) /* f1 */;
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: constructing{{.*}}default
@@ -700,89 +1047,136 @@ void function_invocation() /* f */ {
// CHECK-FIXES: {{^}} function({}) /* f2 */;
function({nullptr}) /* f3 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
+ // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: constructing{{.*}}default
// CHECK-FIXES: {{^}} function({}) /* f3 */;
function({(nullptr)}) /* f4 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
+ // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: constructing{{.*}}default
// CHECK-FIXES: {{^}} function({}) /* f4 */;
function({{}}) /* f5 */; // Default `const CharT*`
- // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
+ // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: constructing{{.*}}default
// CHECK-FIXES: {{^}} function({}) /* f5 */;
}
- // Multiple Argument
+ // Function Argument Initialization With Temporary
{
- function(nullptr, nullptr) /* f6 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: constructing{{.*}}default
- // CHECK-MESSAGES: :[[@LINE-2]]:23: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} function({}, {}) /* f6 */;
+ function(std::string_view(nullptr)) /* f6 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} function(std::string_view()) /* f6 */;
- function((nullptr), (nullptr)) /* f7 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: constructing{{.*}}default
- // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} function({}, {}) /* f7 */;
-
- function({nullptr}, {nullptr}) /* f8 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-MESSAGES: :[[@LINE-2]]:26: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} function({}, {}) /* f8 */;
-
- function({(nullptr)}, {(nullptr)}) /* f9 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-MESSAGES: :[[@LINE-2]]:28: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} function({}, {}) /* f9 */;
-
- function({{}}, {{}}) /* f10 */; // Default `const CharT*`s
- // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing{{.*}}default
- // CHECK-MESSAGES: :[[@LINE-2]]:21: warning: constructing{{.*}}default
- // CHECK-FIXES: {{^}} function({}, {}) /* f10 */;
+ function(std::string_view{nullptr}) /* f7 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} function(std::string_view{}) /* f7 */;
+
+ function((std::string_view) nullptr) /* f8 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} function((std::string_view) {}) /* f8 */;
+
+ function((std::string_view){nullptr}) /* f9 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} function((std::string_view){}) /* f9 */;
+
+ function(static_cast<SV>(nullptr)) /* f10 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} function(static_cast<SV>("")) /* f10 */;
}
}
void assignment(std::string_view sv) /* g */ {
- sv = nullptr /* g1 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: assignment to basic_string_view from null is undefined; replace with the default constructor
- // CHECK-FIXES: {{^}} sv = {} /* g1 */;
+ // Assignment
+ {
+ sv = nullptr /* g1 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: assignment to basic_string_view from null is undefined; replace with the default constructor
+ // CHECK-FIXES: {{^}} sv = {} /* g1 */;
+
+ sv = (nullptr) /* g2 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: assignment{{.*}}default
+ // CHECK-FIXES: {{^}} sv = {} /* g2 */;
+
+ sv = {nullptr} /* g3 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: assignment{{.*}}default
+ // CHECK-FIXES: {{^}} sv = {} /* g3 */;
+
+ sv = {(nullptr)} /* g4 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: assignment{{.*}}default
+ // CHECK-FIXES: {{^}} sv = {} /* g4 */;
+
+ sv = {{}} /* g5 */; // Default `const CharT*`
+ // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: assignment{{.*}}default
+ // CHECK-FIXES: {{^}} sv = {} /* g5 */;
+ }
+
+ // Assignment With Temporary
+ {
+ sv = std::string_view(nullptr) /* g6 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} sv = std::string_view() /* g6 */;
- sv = (nullptr) /* g2 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: assignment{{.*}}default
- // CHECK-FIXES: {{^}} sv = {} /* g2 */;
+ sv = std::string_view{nullptr} /* g7 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} sv = std::string_view{} /* g7 */;
- sv = {nullptr} /* g3 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: assignment{{.*}}default
- // CHECK-FIXES: {{^}} sv = {} /* g3 */;
+ sv = (std::string_view) nullptr /* g8 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} sv = (std::string_view) {} /* g8 */;
- sv = {(nullptr)} /* g4 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: assignment{{.*}}default
- // CHECK-FIXES: {{^}} sv = {} /* g4 */;
+ sv = (std::string_view){nullptr} /* g9 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} sv = (std::string_view){} /* g9 */;
- sv = {{}} /* g5 */; // Default `const CharT*`
- // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: assignment{{.*}}default
- // CHECK-FIXES: {{^}} sv = {} /* g5 */;
+ sv = static_cast<SV>(nullptr) /* g10 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} sv = static_cast<SV>("") /* g10 */;
+ }
}
void pointer_assignment(std::string_view *sv_ptr) /* h */ {
- *sv_ptr = nullptr /* h1 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: assignment{{.*}}default
- // CHECK-FIXES: {{^}} *sv_ptr = {} /* h1 */;
+ // Assignment
+ {
+ *sv_ptr = nullptr /* h1 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: assignment{{.*}}default
+ // CHECK-FIXES: {{^}} *sv_ptr = {} /* h1 */;
- *sv_ptr = (nullptr) /* h2 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: assignment{{.*}}default
- // CHECK-FIXES: {{^}} *sv_ptr = {} /* h2 */;
+ *sv_ptr = (nullptr) /* h2 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: assignment{{.*}}default
+ // CHECK-FIXES: {{^}} *sv_ptr = {} /* h2 */;
- *sv_ptr = {nullptr} /* h3 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: assignment{{.*}}default
- // CHECK-FIXES: {{^}} *sv_ptr = {} /* h3 */;
+ *sv_ptr = {nullptr} /* h3 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: assignment{{.*}}default
+ // CHECK-FIXES: {{^}} *sv_ptr = {} /* h3 */;
- *sv_ptr = {(nullptr)} /* h4 */;
- // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: assignment{{.*}}default
- // CHECK-FIXES: {{^}} *sv_ptr = {} /* h4 */;
+ *sv_ptr = {(nullptr)} /* h4 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: assignment{{.*}}default
+ // CHECK-FIXES: {{^}} *sv_ptr = {} /* h4 */;
+
+ *sv_ptr = {{}} /* h5 */; // Default `const CharT*`
+ // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: assignment{{.*}}default
+ // CHECK-FIXES: {{^}} *sv_ptr = {} /* h5 */;
+ }
+
+ // Assignment With Temporary
+ {
+ *sv_ptr = std::string_view(nullptr) /* h6 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} *sv_ptr = std::string_view() /* h6 */;
+
+ *sv_ptr = std::string_view{nullptr} /* h7 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} *sv_ptr = std::string_view{} /* h7 */;
- *sv_ptr = {{}} /* h5 */; // Default `const CharT*`
- // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: assignment{{.*}}default
- // CHECK-FIXES: {{^}} *sv_ptr = {} /* h5 */;
+ *sv_ptr = (std::string_view) nullptr /* h8 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} *sv_ptr = (std::string_view) {} /* h8 */;
+
+ *sv_ptr = (std::string_view){nullptr} /* h9 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} *sv_ptr = (std::string_view){} /* h9 */;
+
+ *sv_ptr = static_cast<SV>(nullptr) /* h10 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} *sv_ptr = static_cast<SV>("") /* h10 */;
+ }
}
void lesser_comparison(std::string_view sv) /* i */ {
@@ -945,158 +1339,274 @@ void pointer_greater_comparison(std::string_view *sv_ptr) /* l */ {
}
}
-void equality_comparison(std::string_view sv) /* m */ {
+void relative_comparison_with_temporary(std::string_view sv) /* m */ {
+ (void)(sv < std::string_view(nullptr)) /* m1 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(sv < std::string_view()) /* m1 */;
+
+ (void)(sv < std::string_view{nullptr}) /* m2 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(sv < std::string_view{}) /* m2 */;
+
+ (void)(sv < (std::string_view) nullptr) /* m3 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(sv < (std::string_view) {}) /* m3 */;
+
+ (void)(sv < (std::string_view){nullptr}) /* m4 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(sv < (std::string_view){}) /* m4 */;
+
+ (void)(sv < static_cast<SV>(nullptr)) /* m5 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} (void)(sv < static_cast<SV>("")) /* m5 */;
+}
+
+void equality_comparison(std::string_view sv) /* n */ {
// Empty Without Parens
{
- (void)(sv == nullptr) /* m1 */;
+ (void)(sv == nullptr) /* n1 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
- // CHECK-FIXES: {{^}} (void)(sv.empty()) /* m1 */;
+ // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n1 */;
- (void)(sv == (nullptr)) /* m2 */;
+ (void)(sv == (nullptr)) /* n2 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv.empty()) /* m2 */;
+ // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n2 */;
- (void)(nullptr == sv) /* m3 */;
+ (void)(nullptr == sv) /* n3 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv.empty()) /* m3 */;
+ // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n3 */;
- (void)((nullptr) == sv) /* m4 */;
+ (void)((nullptr) == sv) /* n4 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv.empty()) /* m4 */;
+ // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n4 */;
}
// Empty With Parens
{
- (void)((sv) == nullptr) /* m5 */;
+ (void)((sv) == nullptr) /* n5 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
- // CHECK-FIXES: {{^}} (void)(sv.empty()) /* m5 */;
+ // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n5 */;
- (void)((sv) == (nullptr)) /* m6 */;
+ (void)((sv) == (nullptr)) /* n6 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv.empty()) /* m6 */;
+ // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n6 */;
- (void)(nullptr == (sv)) /* m7 */;
+ (void)(nullptr == (sv)) /* n7 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv.empty()) /* m7 */;
+ // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n7 */;
- (void)((nullptr) == (sv)) /* m8 */;
+ (void)((nullptr) == (sv)) /* n8 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv.empty()) /* m8 */;
+ // CHECK-FIXES: {{^}} (void)(sv.empty()) /* n8 */;
}
// Non-Empty Without Parens
{
- (void)((sv) != nullptr) /* m9 */;
+ (void)((sv) != nullptr) /* n9 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* m9 */;
+ // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n9 */;
- (void)((sv) != (nullptr)) /* m10 */;
+ (void)((sv) != (nullptr)) /* n10 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* m10 */;
+ // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n10 */;
- (void)(nullptr != (sv)) /* m11 */;
+ (void)(nullptr != (sv)) /* n11 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* m11 */;
+ // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n11 */;
- (void)((nullptr) != (sv)) /* m12 */;
+ (void)((nullptr) != (sv)) /* n12 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* m12 */;
+ // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n12 */;
}
// Non-Empty With Parens
{
- (void)((sv) != nullptr) /* m13 */;
+ (void)((sv) != nullptr) /* n13 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* m13 */;
+ // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n13 */;
- (void)((sv) != (nullptr)) /* m14 */;
+ (void)((sv) != (nullptr)) /* n14 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* m14 */;
+ // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n14 */;
- (void)(nullptr != (sv)) /* m15 */;
+ (void)(nullptr != (sv)) /* n15 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* m15 */;
+ // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n15 */;
- (void)((nullptr) != (sv)) /* m16 */;
+ (void)((nullptr) != (sv)) /* n16 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* m16 */;
+ // CHECK-FIXES: {{^}} (void)(!sv.empty()) /* n16 */;
}
}
-void pointer_equality_comparison(std::string_view *sv_ptr) /* n */ {
+void pointer_equality_comparison(std::string_view *sv_ptr) /* o */ {
// Empty Without Parens
{
- (void)(*sv_ptr == nullptr) /* n1 */;
+ (void)(*sv_ptr == nullptr) /* o1 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* n1 */;
+ // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o1 */;
- (void)(*sv_ptr == (nullptr)) /* n2 */;
+ (void)(*sv_ptr == (nullptr)) /* o2 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* n2 */;
+ // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o2 */;
- (void)(nullptr == *sv_ptr) /* n3 */;
+ (void)(nullptr == *sv_ptr) /* o3 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* n3 */;
+ // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o3 */;
- (void)((nullptr) == *sv_ptr) /* n4 */;
+ (void)((nullptr) == *sv_ptr) /* o4 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* n4 */;
+ // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o4 */;
}
// Empty With Parens
{
- (void)((*sv_ptr) == nullptr) /* n5 */;
+ (void)((*sv_ptr) == nullptr) /* o5 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* n5 */;
+ // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o5 */;
- (void)((*sv_ptr) == (nullptr)) /* n6 */;
+ (void)((*sv_ptr) == (nullptr)) /* o6 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* n6 */;
+ // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o6 */;
- (void)(nullptr == (*sv_ptr)) /* n7 */;
+ (void)(nullptr == (*sv_ptr)) /* o7 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* n7 */;
+ // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o7 */;
- (void)((nullptr) == (*sv_ptr)) /* n8 */;
+ (void)((nullptr) == (*sv_ptr)) /* o8 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* n8 */;
+ // CHECK-FIXES: {{^}} (void)(sv_ptr->empty()) /* o8 */;
}
// Non-Empty With Parens
{
- (void)((*sv_ptr) != nullptr) /* n9 */;
+ (void)((*sv_ptr) != nullptr) /* o9 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* n9 */;
+ // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o9 */;
- (void)((*sv_ptr) != (nullptr)) /* n10 */;
+ (void)((*sv_ptr) != (nullptr)) /* o10 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* n10 */;
+ // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o10 */;
- (void)(nullptr != (*sv_ptr)) /* n11 */;
+ (void)(nullptr != (*sv_ptr)) /* o11 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* n11 */;
+ // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o11 */;
- (void)((nullptr) != (*sv_ptr)) /* n12 */;
+ (void)((nullptr) != (*sv_ptr)) /* o12 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* n12 */;
+ // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o12 */;
}
// Non-Empty Without Parens
{
- (void)((*sv_ptr) != nullptr) /* n13 */;
+ (void)((*sv_ptr) != nullptr) /* o13 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* n13 */;
+ // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o13 */;
- (void)((*sv_ptr) != (nullptr)) /* n14 */;
+ (void)((*sv_ptr) != (nullptr)) /* o14 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* n14 */;
+ // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o14 */;
- (void)(nullptr != (*sv_ptr)) /* n15 */;
+ (void)(nullptr != (*sv_ptr)) /* o15 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* n15 */;
+ // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o15 */;
- (void)((nullptr) != (*sv_ptr)) /* n16 */;
+ (void)((nullptr) != (*sv_ptr)) /* o16 */;
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing{{.*}}emptiness query
- // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* n16 */;
+ // CHECK-FIXES: {{^}} (void)(!sv_ptr->empty()) /* o16 */;
+ }
+}
+
+void equality_comparison_with_temporary(std::string_view sv) /* p */ {
+ (void)(sv == std::string_view(nullptr)) /* p1 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(sv == std::string_view()) /* p1 */;
+
+ (void)(sv == std::string_view{nullptr}) /* p2 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(sv == std::string_view{}) /* p2 */;
+
+ (void)(sv == (std::string_view) nullptr) /* p3 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(sv == (std::string_view) {}) /* p3 */;
+
+ (void)(sv == (std::string_view){nullptr}) /* p4 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} (void)(sv == (std::string_view){}) /* p4 */;
+
+ (void)(sv == static_cast<SV>(nullptr)) /* p5 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} (void)(sv == static_cast<SV>("")) /* p5 */;
+}
+
+void return_statement() /* q */ {
+ // Return Statement
+ {
+ []() -> SV { return nullptr; } /* q1 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q1 */;
+
+ []() -> SV { return (nullptr); } /* q2 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q2 */;
+
+ []() -> SV { return {nullptr}; } /* q3 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q3 */;
+
+ []() -> SV { return {(nullptr)}; } /* q4 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q4 */;
+
+ []() -> SV { return {{nullptr}}; } /* q5 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q5 */;
+
+ []() -> SV { return {{(nullptr)}}; } /* q6 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q6 */;
+
+ []() -> SV { return {{}}; } /* q7 */; // Default `const CharT*`
+ // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return {}; } /* q7 */;
}
+
+ // Return Statement With Temporary
+ {
+ []() -> SV { return SV(nullptr); } /* q8 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return SV(); } /* q8 */;
+
+ []() -> SV { return SV{nullptr}; } /* q9 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return SV{}; } /* q9 */;
+
+ []() -> SV { return (SV) nullptr; } /* q10 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return (SV) {}; } /* q10 */;
+
+ []() -> SV { return (SV){nullptr}; } /* q11 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: constructing{{.*}}default
+ // CHECK-FIXES: {{^}} []() -> SV { return (SV){}; } /* q11 */;
+
+ []() -> SV { return static_cast<SV>(nullptr); } /* q12 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:41: warning: casting{{.*}}empty string
+ // CHECK-FIXES: {{^}} []() -> SV { return static_cast<SV>(""); } /* q12 */;
+ }
+}
+
+void constructor_invocation() /* r */ {
+ struct AcceptsSV {
+ explicit AcceptsSV(std::string_view) {}
+ } r1(nullptr);
+ // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: passing null as basic_string_view is undefined; replace with the empty string
+ // CHECK-FIXES: {{^}} } r1("");
+
+ (void)(AcceptsSV{nullptr}) /* r2 */;
+ // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: passing{{.*}}empty string
+ // CHECK-FIXES: {{^}} (void)(AcceptsSV{""}) /* r2 */;
+
+ AcceptsSV r3{nullptr};
+ // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: passing{{.*}}empty string
+ // CHECK-FIXES: {{^}} AcceptsSV r3{""};
}
More information about the cfe-commits
mailing list