Add new clang-tidy check for string_view(nullptr)

[CJ-Johnson]

Summary

Checks for various ways that the const CharT* constructor of std::basic_string_view can be passed a null argument and replaces them with the default constructor in most cases. For the comparison operators, braced initializer list does not compile so instead a call to .empty() or the empty string literal are used, where appropriate.

This prevents code from invoking behavior which is unconditionally undefined. The single-argument const CharT* constructor does not check for the null case before dereferencing its input. The standard is slated to add an explicitly-deleted overload to catch some of these cases: wg21.link/p2166

https://reviews.llvm.org/D114823 is a companion change to prevent duplicate warnings from the bugprone-string-constructor check.

[CJ-Johnson]

Update docs to reflect current state

[CJ-Johnson]

Rebase on head

[CJ-Johnson]

Remove mistaken changes

[CJ-Johnson]

Remove mistaken changes

[CJ-Johnson]

Add missing newline

[Sockke]

This seems to be an existing check. Have you compared it with bugprone-string-constructor?

[CJ-Johnson]

In D113148#3107897, @Sockke wrote:

This seems to be an existing check. Have you compared it with bugprone-string-constructor?

Thanks for the suggestion! From what I can tell, bugprone-string-constructor check only has warnings and does not provide fixes in most cases. The goal of bugprone-stringview-nullptr is to robustly enumerate the many cases that it cares about and provide fixes. For that reason, I think making it a separate check is best.

[Sockke]

In D113148#3108705, @CJ-Johnson wrote:

In D113148#3107897, @Sockke wrote:

This seems to be an existing check. Have you compared it with bugprone-string-constructor?

Thanks for the suggestion! From what I can tell, bugprone-string-constructor check only has warnings and does not provide fixes in most cases. The goal of bugprone-stringview-nullptr is to robustly enumerate the many cases that it cares about and provide fixes. For that reason, I think making it a separate check is best.

Yes, But i think that improving existing check is the best way. Because improving bugprone-string-construct in a new check may make developers confused and cause redundant overlap.
Let's see if @aaron.ballman or @whisperity has any comments?

[aaron.ballman]

In D113148#3108960, @Sockke wrote:

In D113148#3108705, @CJ-Johnson wrote:

In D113148#3107897, @Sockke wrote:

This seems to be an existing check. Have you compared it with bugprone-string-constructor?

Thanks for the suggestion! From what I can tell, bugprone-string-constructor check only has warnings and does not provide fixes in most cases. The goal of bugprone-stringview-nullptr is to robustly enumerate the many cases that it cares about and provide fixes. For that reason, I think making it a separate check is best.

Yes, But i think that improving existing check is the best way. Because improving bugprone-string-construct in a new check may make developers confused and cause redundant overlap.
Let's see if @aaron.ballman or @whisperity has any comments?

Generally speaking, we prefer to improve the existing checks. I think bugprone-string-constructor would probably be a better place for the constructor-related functionality. But that still means we don't have a good place for things like the assignment and comparison functionality, and it seems more useful to keep all of the string_view-with-nullptr logic in one place. That said, we should be careful we're not too onerous when users enable all bugprone checks together.

[CJ-Johnson]

Remove trailing whitespace

[CJ-Johnson]

In D113148#3108993, @aaron.ballman wrote:

Generally speaking, we prefer to improve the existing checks. I think bugprone-string-constructor would probably be a better place for the constructor-related functionality. But that still means we don't have a good place for things like the assignment and comparison functionality, and it seems more useful to keep all of the string_view-with-nullptr logic in one place. That said, we should be careful we're not too onerous when users enable all bugprone checks together.

I agree with the statement "it seems more useful to keep all of the string_view-with-nullptr logic in one place". To me, these are very logically related. The fact that some of it is constructor based is not as useful from a user perspective. The relationship between nullptr and string_view is more important, in my view.

As for "we should be careful we're not too onerous when users enable all bugprone checks together.", these fixes are about preventing UB. While I did put this in the "bugprone" module, perhaps "prone" is the wrong way to think about it. It's unconditionally UB in all cases, not just a potential bug. The suggested fixes are important for preventing crashes in the short term, but more importantly for allowing the code to build in the future, since the constructor overload basic_string_view(nullptr_t) = delete; is being added.

[aaron.ballman]

In D113148#3109190, @CJ-Johnson wrote:

As for "we should be careful we're not too onerous when users enable all bugprone checks together.", these fixes are about preventing UB. While I did put this in the "bugprone" module, perhaps "prone" is the wrong way to think about it. It's unconditionally UB in all cases, not just a potential bug. The suggested fixes are important for preventing crashes in the short term, but more importantly for allowing the code to build in the future, since the constructor overload basic_string_view(nullptr_t) = delete; is being added.

The concern I have is that a user passes -checks=-*, bugprone-* and gets two diagnostics on the same line for the same issue. There is precedence, but usually clang-tidy only gets in this situation when the user enables checks from different modules (I don't know of any case where it happens within the same module). Your existing test cases have significant coverage already: https://godbolt.org/z/49nGYEGzq so this isn't a theoretical concern -- anyone checking against all bugprone (which is pretty typical) will get duplicate diagnostics. So we're in a bit of a novel situation with this patch, and I'm not certain what the correct answer is. I see a few paths:

• accept that there are two diagnostics for the same code construct
• remove the string_view nullptr checking functionality from bugprone-string-constructor so it only lives in the new check
• remove the constructor checking functionality from the new check so it only lives in bugprone-string-constructor
• have both of the checks look to see whether the other check is enabled before issuing the diagnostic and pick one of them to be the "winner" so there's only one diagnostic

There's pros and cons to all of these approaches (and maybe there are other approaches to consider as well). I sort of lean towards the last option, but that could be confusing for people trying to suppress diagnostics. e.g., they could write NOLINT(bugprone-string-constructor) to silence the diagnostic and then they get a different diagnostic they also have to silence. However, I also sort of think that confusion is not likely to happen in practice because 1) users are more likely to fix their code than silence *this* warning, 2) users are more likely to write NOLINT without a specific check, so all tidy diagnostics would be suppressed. But it's still a bit of concern as a precedent.

@alexfh -- as code owner, do you have thoughts here?

clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp

85

This (and many others) also generates -Wbraced-scalar-init, is that intentional?

[CJ-Johnson]

Thanks for the additional info, @aaron.ballman! I had not considered the issues with duplicate warnings. I agree that it would be annoying for users. That being the case, the second option ("remove the string_view nullptr checking functionality from bugprone-string-constructor so it only lives in the new check") sounds the most appealing to me, personally.

clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp

85

My goal was just to be thorough in the cases tested. It's not an endorsement of the source patterns. :)

[CJ-Johnson]

Fix spelling error

[CJ-Johnson]

Change static_cast suggested edit to use parens instead of braces

[CJ-Johnson]

Remove double brackets for list initialization and use default initialization to avoid most vexing parse

[CJ-Johnson]

nits

[CJ-Johnson]

Update test file to use truncated messages

[CJ-Johnson]

clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp

85

As a followup to this: I've added additional test cases and a minor change to the AST matchers to catch another form of the -Wbraced-scalar-init pattern.

This: accepts_string_view({{}});

This pattern will select the const CharT* constructor overload and then value-initialize the argument, causing a null deref. It happens to not include the nullptr literal but it has the exact same effect as accepts_string_view(nullptr); and accepts_string_view({nullptr});

[CJ-Johnson]

Add AST matcher support and tests for {{}} case where a null pointer is implicitly created

[CJ-Johnson]

Add missing newline

[CJ-Johnson]

Rebase on head

[CJ-Johnson]

Add additional tests for sv.empty() cases to ensure parens are removed where appropriate

[CJ-Johnson]

Add missing test cases

[ymandel]

This looks really good. An impressive effort! Just a few changes. Also, please ping Alex to get his opinion on the high level issue.

clang-tools-extra/clang-tidy/bugprone/StringviewNullptrCheck.cpp

63

68

76

And more below...

91

Here and throughout the matchers: in general, has is a fallback when you don't have a more specific matcher. In this case, It think you mean to be testing the initialization expression, in which case you should query that directly: hasInitializer. I'd recommend you revisit the uses of has and check in each case if there's a more specific query. That's both cheaper (doesn't need to iterate through all children) and more readable (because it expresses the intent).

clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp

135–148

what are these lines doing?

[CJ-Johnson]

clang-tools-extra/clang-tidy/bugprone/StringviewNullptrCheck.cpp

76

Updated all 9 of them. Thanks!

91

Thanks for the suggestion! I went back through all of the has calls and replaced the ones I could with something more specific.

clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp

135–148

These lines are not "tests" themselves but they clearly document that all of the various permutations have been considered. If someone reads the test file and thinks "what about this other case?", these demonstrate that such other cases have been considered but are not valid :)

[CJ-Johnson]

Address review comments from Yitzie

[whisperity]

In D113148#3109190, @CJ-Johnson wrote:

In D113148#3108993, @aaron.ballman wrote:

Generally speaking, we prefer to improve the existing checks. I think bugprone-string-constructor would probably be a better place for the constructor-related functionality. But that still means we don't have a good place for things like the assignment and comparison functionality, and it seems more useful to keep all of the string_view-with-nullptr logic in one place. That said, we should be careful we're not too onerous when users enable all bugprone checks together.

As for "we should be careful we're not too onerous when users enable all bugprone checks together.", these fixes are about preventing UB. While I did put this in the "bugprone" module, perhaps "prone" is the wrong way to think about it. It's unconditionally UB in all cases, not just a potential bug. The suggested fixes are important for preventing crashes in the short term, but more importantly for allowing the code to build in the future, since the constructor overload basic_string_view(nullptr_t) = delete; is being added.

@aaron.ballman Maybe we should do something to ease the burden of bugprone- becoming a catch-all basket, and create a new checker group for the "unconditional UB" or "in almost all cases this will make you do bad things" kinds of stuff.

clang-tools-extra/docs/ReleaseNotes.rst

82–90

Usually we only put a one sentence short summary into the release notes.

clang-tools-extra/docs/clang-tidy/checks/bugprone-stringview-nullptr.rst

14–15

You mentioned in the review discussion that a constructor taking std::nullptr_t will be added with an explicit = delete;. Maybe it is worth mentioning it here, if we have a standard version or a proposal on track for changing the STL like that?

17–18

Will this work? Isn't the : making RST confused here? You usually need an empty line because the block "instance" may be given additional options in RST.

It might compile the docs still, so this is the kind of thing that must be verified visually.

47

There should be a .. note:: block which renders a nice box of note with an icon.

50

Clang-Tidy. Or just simply "this check".

54

ditto.

[aaron.ballman]

In D113148#3130779, @whisperity wrote:

In D113148#3109190, @CJ-Johnson wrote:

In D113148#3108993, @aaron.ballman wrote:

Generally speaking, we prefer to improve the existing checks. I think bugprone-string-constructor would probably be a better place for the constructor-related functionality. But that still means we don't have a good place for things like the assignment and comparison functionality, and it seems more useful to keep all of the string_view-with-nullptr logic in one place. That said, we should be careful we're not too onerous when users enable all bugprone checks together.

As for "we should be careful we're not too onerous when users enable all bugprone checks together.", these fixes are about preventing UB. While I did put this in the "bugprone" module, perhaps "prone" is the wrong way to think about it. It's unconditionally UB in all cases, not just a potential bug. The suggested fixes are important for preventing crashes in the short term, but more importantly for allowing the code to build in the future, since the constructor overload basic_string_view(nullptr_t) = delete; is being added.

@aaron.ballman Maybe we should do something to ease the burden of bugprone- becoming a catch-all basket, and create a new checker group for the "unconditional UB" or "in almost all cases this will make you do bad things" kinds of stuff.

bugprone was originally added because misc was becoming too much of a catch-all basket and we wanted a new group for the "doing this is a bug" kind of checks, so there's precedent for splitting groups when we need finer granularity. However, we had quite a few checks that could be moved from misc to bugrone during that switch. If we added a group for unconditional UB (or morally similar), it'd be good to know how many checks we think need to move and what sort of checks we envision the new module encouraging in the future. That'll help inform us whether it's good value to make a split or not.

[alexfh]

In D113148#3127646, @ymandel wrote:

This looks really good. An impressive effort! Just a few changes. Also, please ping Alex to get his opinion on the high level issue.

Since this check focuses really well on the issue of creating string_view from nullptr (and unlike the other check in this case, provides automated fixes), it seems best to limit the warning for nullptr argument in bugprone-string-constructor to std::string.

As for creating a "certainly bugs" / "unconditional UB" module: how many checks apart from this one would fall into that category? From a very brief look I found bugprone-dangling-handle and bugprone-undelegated-constructor. The latter could likely be reimplemented as a clang diagnostic. A separate module for two or three checks doesn't sound particularly exciting.

[CJ-Johnson]

Address reviewer comments

[CJ-Johnson]

Rebase on head

[CJ-Johnson]

Thank you all for the feedback! Would it be ok to proceed with removing the nullptr checking for basic_string_view in bugprone-string-constructor, as Alex indicated?

[CJ-Johnson]

Address nits

[CJ-Johnson]

Rebase on head

[CJ-Johnson]

Pinging this thread with https://reviews.llvm.org/D113148

If we land both this revision and that one, then duplicate warnings won't be a problem. :)

[CJ-Johnson]

Add missing comment lines

[ymandel]

To other reviewers: barring any additional comments, I will push this patch tomorrow morning (CJ doesn't have commit rights).

clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp

118–131

nit: personally, i'd just delete these -- anything that doens't compile isn't really of interest to clang tidy. While I see the educational value, these kinds of comments are prone to bitrot (since we're not actually testing anything) and therefore have questionable value even for education.

135–148

ah, i see. maybe put in a comment to that respect?

[CJ-Johnson]

Delete non-functional test cases (which were previously commented out)

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

 #include "SignalHandlerCheck.h"
 #include "SignedCharMisuseCheck.h"
 #include "SizeofContainerCheck.h"
 #include "SizeofExpressionCheck.h"
 #include "SpuriouslyWakeUpFunctionsCheck.h"
 #include "StringConstructorCheck.h"
 #include "StringIntegerAssignmentCheck.h"
 #include "StringLiteralWithEmbeddedNulCheck.h"
+#include "StringviewNullptrCheck.h"
 #include "SuspiciousEnumUsageCheck.h"
 #include "SuspiciousIncludeCheck.h"
 #include "SuspiciousMemoryComparisonCheck.h"
 #include "SuspiciousMemsetUsageCheck.h"
 #include "SuspiciousMissingCommaCheck.h"
 #include "SuspiciousSemicolonCheck.h"
 #include "SuspiciousStringCompareCheck.h"
 #include "SwappedArgumentsCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<SpuriouslyWakeUpFunctionsCheck>(
         "bugprone-spuriously-wake-up-functions");
     CheckFactories.registerCheck<StringConstructorCheck>(
         "bugprone-string-constructor");
     CheckFactories.registerCheck<StringIntegerAssignmentCheck>(
         "bugprone-string-integer-assignment");
     CheckFactories.registerCheck<StringLiteralWithEmbeddedNulCheck>(
         "bugprone-string-literal-with-embedded-nul");
+    CheckFactories.registerCheck<StringviewNullptrCheck>(
+        "bugprone-stringview-nullptr");
     CheckFactories.registerCheck<SuspiciousEnumUsageCheck>(
         "bugprone-suspicious-enum-usage");
     CheckFactories.registerCheck<SuspiciousIncludeCheck>(
         "bugprone-suspicious-include");
     CheckFactories.registerCheck<SuspiciousMemoryComparisonCheck>(
         "bugprone-suspicious-memory-comparison");
     CheckFactories.registerCheck<SuspiciousMemsetUsageCheck>(
         "bugprone-suspicious-memset-usage");

clang-tools-extra/clang-tidy/bugprone/CMakeLists.txt

add_clang_library(clangTidyBugproneModule
   SignalHandlerCheck.cpp
   SignedCharMisuseCheck.cpp
   SizeofContainerCheck.cpp
   SizeofExpressionCheck.cpp
   SpuriouslyWakeUpFunctionsCheck.cpp
   StringConstructorCheck.cpp
   StringIntegerAssignmentCheck.cpp
   StringLiteralWithEmbeddedNulCheck.cpp
+  StringviewNullptrCheck.cpp
   SuspiciousEnumUsageCheck.cpp
   SuspiciousIncludeCheck.cpp
   SuspiciousMemoryComparisonCheck.cpp
   SuspiciousMemsetUsageCheck.cpp
   SuspiciousMissingCommaCheck.cpp
   SuspiciousSemicolonCheck.cpp
   SuspiciousStringCompareCheck.cpp
   SwappedArgumentsCheck.cpp

clang-tools-extra/clang-tidy/bugprone/StringviewNullptrCheck.h

+//===--- StringviewNullptrCheck.h - clang-tidy ------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGVIEWNULLPTRCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGVIEWNULLPTRCHECK_H
+
+#include "../utils/TransformerClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+/// Checks for various ways that the `nullptr` literal can be passed into the
+/// `const CharT*` constructor of `basic_string_view` and replaces them with
+/// the default constructor in most cases. For the comparison operators, braced
+/// initializer list does not compile so instead the empty string is used.
+/// Also, `==` and `!=` are replaced with calls to `.empty()`.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-stringview-nullptr.html
+class StringviewNullptrCheck : public utils::TransformerClangTidyCheck {
+public:
+  StringviewNullptrCheck(StringRef Name, ClangTidyContext *Context);
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+};
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGVIEWNULLPTRCHECK_H

clang-tools-extra/clang-tidy/bugprone/StringviewNullptrCheck.cpp

+//===--- StringviewNullptrCheck.cpp - clang-tidy --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "StringviewNullptrCheck.h"
+#include "../utils/TransformerClangTidyCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Tooling/Transformer/RangeSelector.h"
+#include "clang/Tooling/Transformer/RewriteRule.h"
+#include "clang/Tooling/Transformer/Stencil.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+using namespace ::clang::ast_matchers;
+using namespace ::clang::transformer;
+
+RewriteRule StringviewNullptrCheckImpl() {
+  auto construction_warning =
+      cat("constructing basic_string_view from null is undefined; replace with "
+          "the default constructor");
+  auto assignment_warning =
+      cat("assignment to basic_string_view from null is undefined; replace "
+          "with the default constructor");
+  auto relative_comparison_warning =
+      cat("comparing basic_string_view to null is undefined; replace with the "
+          "empty string");
+  auto equality_comparison_warning =
+      cat("comparing basic_string_view to null is undefined; replace with the "
+          "emptiness query");
+  auto StringViewConstructingFromNullptrExpr =
+      cxxConstructExpr(
+          hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(
+              cxxRecordDecl(hasName("std::basic_string_view")))))),
+          argumentCountIs(1), has(expr().bind("nullptr_argument_expr")),
+          hasArgument(
+              0, anyOf(ignoringParenImpCasts(cxxNullPtrLiteralExpr()),
+                       initListExpr(hasInit(0, ignoringParenImpCasts(
+                                                   cxxNullPtrLiteralExpr()))))))
+          .bind("construct_expr");
+
+  auto HandleTemporaryCXXFunctionalCastExpr = makeRule(
+      cxxFunctionalCastExpr(
+          hasSourceExpression(StringViewConstructingFromNullptrExpr)),
+      changeTo(node("nullptr_argument_expr"), cat("")), construction_warning);
+
+  auto HandleTemporaryCXXTemporaryObjectExpr = makeRule(
+      cxxTemporaryObjectExpr(StringViewConstructingFromNullptrExpr,
+                             unless(hasParent(compoundLiteralExpr()))),
+      changeTo(node("nullptr_argument_expr"), cat("")), construction_warning);
+
+  auto HandleTemporaryCStyleCaseExpr = makeRule(
+      cStyleCastExpr(
+          hasSourceExpression(StringViewConstructingFromNullptrExpr)),
+      changeTo(node("nullptr_argument_expr"), cat("{}")), construction_warning);
+
+  auto HandleTemporaryCompoundLiteralExpr = makeRule(
+      compoundLiteralExpr(has(StringViewConstructingFromNullptrExpr)),
+      changeTo(node("nullptr_argument_expr"), cat("")), construction_warning);
+
+  auto HandleTemporaryCXXStaticCastExpr = makeRule(
+      cxxStaticCastExpr(has(StringViewConstructingFromNullptrExpr),
+                        hasTypeLoc(typeLoc().bind("type_loc"))),
+      changeTo(node("nullptr_argument_expr"), cat(node("type_loc"), "{}")),
+      construction_warning);
+
+  auto HandleStackCopyInitialization = makeRule(
+      declStmt(has(varDecl(has(implicitCastExpr(
+          ignoringImpCasts(StringViewConstructingFromNullptrExpr)))))),
+      changeTo(node("nullptr_argument_expr"), cat("{}")), construction_warning);
+
+  auto HandleStackDirectAndBracedInitialization = makeRule(
+      declStmt(has(varDecl(has(StringViewConstructingFromNullptrExpr)))),
+      changeTo(node("nullptr_argument_expr"), cat(" {} ")),
+      construction_warning);
+
+  auto HandleFieldCopyInitialization = makeRule(
+      fieldDecl(has(implicitCastExpr(
+          ignoringImpCasts(StringViewConstructingFromNullptrExpr)))),
+      changeTo(node("nullptr_argument_expr"), cat("{}")), construction_warning);
+
+  auto HandleFieldOtherInitialization = makeRule(
+      fieldDecl(has(StringViewConstructingFromNullptrExpr)),
+      changeTo(node("nullptr_argument_expr"), cat("")), construction_warning);
+
+  auto HandleConstructorInitialization = makeRule(
+      cxxCtorInitializer(
+          withInitializer(StringViewConstructingFromNullptrExpr)),
+      changeTo(node("nullptr_argument_expr"), cat("")), construction_warning);
+
+  auto HandleDefaultArgumentInitialization = makeRule(
+      parmVarDecl(hasInitializer(
+          implicitCastExpr(has(StringViewConstructingFromNullptrExpr)))),
+      changeTo(node("nullptr_argument_expr"), cat("{}")), construction_warning);
+
+  auto HandleDefaultArgumentListInitialization = makeRule(
+      parmVarDecl(hasInitializer(StringViewConstructingFromNullptrExpr)),
+      changeTo(node("nullptr_argument_expr"), cat("")), construction_warning);
+
+  auto HandleHeapInitialization = makeRule(
+      cxxNewExpr(has(StringViewConstructingFromNullptrExpr)),
+      changeTo(node("nullptr_argument_expr"), cat("")), construction_warning);
+
+  auto HandleFunctionArgumentInitialization = makeRule(
+      expr(hasParent(callExpr(unless(cxxOperatorCallExpr()))),
+           implicitCastExpr(has(StringViewConstructingFromNullptrExpr))),
+      changeTo(node("nullptr_argument_expr"), cat("{}")), construction_warning);
+
+  auto HandleFunctionArgumentListInitialization = makeRule(
+      expr(hasParent(callExpr(unless(cxxOperatorCallExpr()))),
+           StringViewConstructingFromNullptrExpr),
+      changeTo(node("nullptr_argument_expr"), cat("")), construction_warning);
+
+  auto HandleAssignment = makeRule(
+      materializeTemporaryExpr(
+          hasParent(cxxOperatorCallExpr(hasOverloadedOperatorName("="))),
+          has(StringViewConstructingFromNullptrExpr)),
+      changeTo(node("construct_expr"), cat("{}")), assignment_warning);
+
+  auto HandleRelativeComparison = makeRule(
+      implicitCastExpr(hasParent(cxxOperatorCallExpr(
+                           hasAnyOverloadedOperatorName("<", "<=", ">", ">="))),
+                       has(StringViewConstructingFromNullptrExpr)),
+      changeTo(node("nullptr_argument_expr"), cat("\"\"")),
+      relative_comparison_warning);
+
+  auto HandleEmptyEqualityComparison = makeRule(
+      cxxOperatorCallExpr(
+          hasOverloadedOperatorName("=="),
+          hasOperands(
+              traverse(clang::TK_IgnoreUnlessSpelledInSource,
+                       expr().bind("string_view_instance")),
+              implicitCastExpr(has(StringViewConstructingFromNullptrExpr))))
+          .bind("root"),
+      changeTo(node("root"),
+               cat(access("string_view_instance", cat("empty")), "()")),
+      equality_comparison_warning);
+
+  auto HandleNonEmptyEqualityComparison = makeRule(
+      cxxOperatorCallExpr(
+          hasOverloadedOperatorName("!="),
+          hasOperands(
+              traverse(clang::TK_IgnoreUnlessSpelledInSource,
+                       expr().bind("string_view_instance")),
+              implicitCastExpr(has(StringViewConstructingFromNullptrExpr))))
+          .bind("root"),
+      changeTo(node("root"),
+               cat("!", access("string_view_instance", cat("empty")), "()")),
+      equality_comparison_warning);
+
+  return applyFirst(
+      {HandleTemporaryCXXFunctionalCastExpr,
+       HandleTemporaryCXXTemporaryObjectExpr, HandleTemporaryCStyleCaseExpr,
+       HandleTemporaryCompoundLiteralExpr, HandleTemporaryCXXStaticCastExpr,
+       HandleStackCopyInitialization, HandleStackDirectAndBracedInitialization,
+       HandleFieldCopyInitialization, HandleFieldOtherInitialization,
+       HandleConstructorInitialization, HandleDefaultArgumentInitialization,
+       HandleDefaultArgumentListInitialization, HandleHeapInitialization,
+       HandleFunctionArgumentInitialization,
+       HandleFunctionArgumentListInitialization, HandleAssignment,
+       HandleRelativeComparison, HandleEmptyEqualityComparison,
+       HandleNonEmptyEqualityComparison});
+}
+
+StringviewNullptrCheck::StringviewNullptrCheck(StringRef Name,
+                                               ClangTidyContext *Context)
+    : utils::TransformerClangTidyCheck(StringviewNullptrCheckImpl(), Name,
+                                       Context) {}
+
+bool StringviewNullptrCheck::isLanguageVersionSupported(
+    const LangOptions &LangOpts) const {
+  return LangOpts.CPlusPlus17;
+}
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang

clang-tools-extra/docs/ReleaseNotes.rst

- Added support for globbing in `NOLINT*` expressions, to simplify suppressing
   multiple warnings in the same line.
 
 - Added support for `NOLINTBEGIN` ... `NOLINTEND` comments to suppress
   Clang-Tidy warnings over multiple lines.
 
 New checks
 ^^^^^^^^^^
 
+- New :doc:`bugprone-stringview-nullptr
+  <clang-tidy/checks/bugprone-stringview-nullptr>` check.
+
+  Checks for various ways that the `nullptr` literal can be passed into the
+  `const CharT*` constructor of `basic_string_view` and replaces them with
+  the default constructor in most cases. For the comparison operators, braced
+  initializer list does not compile so instead the empty string is used.
+  Also, `==` and `!=` are replaced with calls to `.empty()`.
+
 - New :doc:`bugprone-suspicious-memory-comparison
   <clang-tidy/checks/bugprone-suspicious-memory-comparison>` check.
 
   Finds potentially incorrect calls to ``memcmp()`` based on properties of the
   arguments.
 
 - New :doc:`cppcoreguidelines-virtual-class-destructor
   <clang-tidy/checks/cppcoreguidelines-virtual-class-destructor>` check.
 
   Finds virtual classes whose destructor is neither public and virtual nor
   protected and non-virtual.

clang-tools-extra/docs/clang-tidy/checks/bugprone-stringview-nullptr.rst

+.. title:: clang-tidy - bugprone-stringview-nullptr
+
+bugprone-stringview-nullptr
+===========================
+
+Checks for various ways that the ``nullptr`` literal can be passed into the
+``const CharT*`` constructor of ``basic_string_view`` and replaces them with
+the default constructor in most cases. For the comparison operators, braced
+initializer list does not compile so instead the empty string is used. Also,
+``==`` and ``!=`` are replaced with calls to ``.empty()``.
+
+This prevents code from invoking behavior which is unconditionally undefined.
+The single-argument ``const char*`` constructor of ``std::string_view`` does
+not check for the null case before dereferencing its input.
+
+.. code-block:: c++
+
+  std::string_view sv = nullptr;
+
+  sv = nullptr;
+
+  bool is_empty = sv == nullptr;
+  bool isnt_empty = sv != nullptr;
+
+  accepts_sv(nullptr);
+
+  accepts_sv({nullptr, 0});  // unchanged
+
+becomes
+
+.. code-block:: c++
+
+  std::string_view sv = {};
+
+  sv = {};
+
+  bool is_empty = sv.empty();
+  bool isnt_empty = !sv.empty();
+
+  accepts_sv({});
+
+  accepts_sv({nullptr, 0});  // unchanged
 No newline at end of file

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `bugprone-signal-handler <bugprone-signal-handler.html>`_,
    `bugprone-signed-char-misuse <bugprone-signed-char-misuse.html>`_,
    `bugprone-sizeof-container <bugprone-sizeof-container.html>`_,
    `bugprone-sizeof-expression <bugprone-sizeof-expression.html>`_,
    `bugprone-spuriously-wake-up-functions <bugprone-spuriously-wake-up-functions.html>`_,
    `bugprone-string-constructor <bugprone-string-constructor.html>`_, "Yes"
    `bugprone-string-integer-assignment <bugprone-string-integer-assignment.html>`_, "Yes"
    `bugprone-string-literal-with-embedded-nul <bugprone-string-literal-with-embedded-nul.html>`_,
+   `bugprone-stringview-nullptr <bugprone-stringview-nullptr.html>`_,
    `bugprone-suspicious-enum-usage <bugprone-suspicious-enum-usage.html>`_,
    `bugprone-suspicious-include <bugprone-suspicious-include.html>`_,
    `bugprone-suspicious-memory-comparison <bugprone-suspicious-memory-comparison.html>`_,
    `bugprone-suspicious-memset-usage <bugprone-suspicious-memset-usage.html>`_, "Yes"
    `bugprone-suspicious-missing-comma <bugprone-suspicious-missing-comma.html>`_,
    `bugprone-suspicious-semicolon <bugprone-suspicious-semicolon.html>`_, "Yes"
    `bugprone-suspicious-string-compare <bugprone-suspicious-string-compare.html>`_, "Yes"
    `bugprone-swapped-arguments <bugprone-swapped-arguments.html>`_, "Yes"

clang-tools-extra/test/clang-tidy/checkers/bugprone-stringview-nullptr.cpp

+// RUN: %check_clang_tidy %s bugprone-stringview-nullptr -std=c++17 %t
+
+namespace std {
+
+using nullptr_t = decltype(nullptr);
+
+template <typename T>
+T &&declval();
+
+template <typename T>
+struct type_identity { using type = T; };
+template <typename T>
+using type_identity_t = typename type_identity<T>::type;
+
+template <typename C>
+class basic_string_view {
+public:
+  basic_string_view();
+  basic_string_view(const C *);
+  basic_string_view(const basic_string_view &);
+  basic_string_view &operator=(const basic_string_view &);
+};
+
+template <typename C>
+bool operator<(basic_string_view<C>, basic_string_view<C>);
+template <typename C>
+bool operator<(type_identity_t<basic_string_view<C>>, basic_string_view<C>);
+template <typename C>
+bool operator<(basic_string_view<C>, type_identity_t<basic_string_view<C>>);
+
+template <typename C>
+bool operator<=(basic_string_view<C>, basic_string_view<C>);
+template <typename C>
+bool operator<=(type_identity_t<basic_string_view<C>>, basic_string_view<C>);
+template <typename C>
+bool operator<=(basic_string_view<C>, type_identity_t<basic_string_view<C>>);
+
+template <typename C>
+bool operator>(basic_string_view<C>, basic_string_view<C>);
+template <typename C>
+bool operator>(type_identity_t<basic_string_view<C>>, basic_string_view<C>);
+template <typename C>
+bool operator>(basic_string_view<C>, type_identity_t<basic_string_view<C>>);
+
+template <typename C>
+bool operator>=(basic_string_view<C>, basic_string_view<C>);
+template <typename C>
+bool operator>=(type_identity_t<basic_string_view<C>>, basic_string_view<C>);
+template <typename C>
+bool operator>=(basic_string_view<C>, type_identity_t<basic_string_view<C>>);
+
+template <typename C>
+bool operator==(basic_string_view<C>, basic_string_view<C>);
+template <typename C>
+bool operator==(type_identity_t<basic_string_view<C>>, basic_string_view<C>);
+template <typename C>
+bool operator==(basic_string_view<C>, type_identity_t<basic_string_view<C>>);
+
+template <typename C>
+bool operator!=(basic_string_view<C>, basic_string_view<C>);
+template <typename C>
+bool operator!=(type_identity_t<basic_string_view<C>>, basic_string_view<C>);
+template <typename C>
+bool operator!=(basic_string_view<C>, type_identity_t<basic_string_view<C>>);
+
+using string_view = basic_string_view<char>;
+
+} // namespace std
+
+void function(std::string_view);
+void function(std::string_view, std::string_view);
+
+void temporary_construction() /* a */ {
+  // Functional Cast
+  {
+    (void)(std::string_view(nullptr)) /* a1 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(std::string_view()) /* a1 */;{{$}}
+
+    (void)(std::string_view((nullptr))) /* a2 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(std::string_view()) /* a2 */;{{$}}
+
+    (void)(std::string_view({nullptr})) /* a3 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(std::string_view()) /* a3 */;{{$}}
+
+    (void)(std::string_view({(nullptr)})) /* a4 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(std::string_view()) /* a4 */;{{$}}
+
+    // (void)(const std::string_view(nullptr)) /* a5 */;
+    // CV qualifiers do not compile in this context
+
+    // (void)(const std::string_view((nullptr))) /* a6 */;
+    // CV qualifiers do not compile in this context
+
+    // (void)(const std::string_view({nullptr})) /* a7 */;
+    // CV qualifiers do not compile in this context
+
+    // (void)(const std::string_view({(nullptr)})) /* a8 */;
+    // CV qualifiers do not compile in this context
+  }
+
+  // Temporary Object
+  {
+    (void)(std::string_view{nullptr}) /* a9 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(std::string_view{}) /* a9 */;{{$}}
+
+    (void)(std::string_view{(nullptr)}) /* a10 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(std::string_view{}) /* a10 */;{{$}}
+
+    (void)(std::string_view{{nullptr}}) /* a11 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(std::string_view{}) /* a11 */;{{$}}
+
+    (void)(std::string_view{{(nullptr)}}) /* a12 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(std::string_view{}) /* a12 */;{{$}}
+
+    // (void)(const std::string_view{nullptr}) /* a13 */;
+    // CV qualifiers do not compile in this context
+
+    // (void)(const std::string_view{(nullptr)}) /* a14 */;
+    // CV qualifiers do not compile in this context
+
+    // (void)(const std::string_view{{nullptr}}) /* a15 */;
+    // CV qualifiers do not compile in this context
+
+    // (void)(const std::string_view{{(nullptr)}}) /* a16 */;
+    // CV qualifiers do not compile in this context
+  }
+
+  // C-Style Cast && Compound Literal
+  {
+    (void)((std::string_view) nullptr) /* a17 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((std::string_view) {}) /* a17 */;{{$}}
+
+    (void)((std::string_view)(nullptr)) /* a18 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((std::string_view){}) /* a18 */;{{$}}
+
+    (void)((std::string_view){nullptr}) /* a19 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((std::string_view){}) /* a19 */;{{$}}
+
+    (void)((std::string_view){(nullptr)}) /* a20 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((std::string_view){}) /* a20 */;{{$}}
+
+    (void)((std::string_view){{nullptr}}) /* a21 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((std::string_view){}) /* a21 */;{{$}}
+
+    (void)((std::string_view){{(nullptr)}}) /* a22 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((std::string_view){}) /* a22 */;{{$}}
+
+    (void)((const std::string_view) nullptr) /* a23 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((const std::string_view) {}) /* a23 */;{{$}}
+
+    (void)((const std::string_view)(nullptr)) /* a24 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((const std::string_view){}) /* a24 */;{{$}}
+
+    (void)((const std::string_view){nullptr}) /* a25 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((const std::string_view){}) /* a25 */;{{$}}
+
+    (void)((const std::string_view){(nullptr)}) /* a26 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((const std::string_view){}) /* a26 */;{{$}}
+
+    (void)((const std::string_view){{nullptr}}) /* a27 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((const std::string_view){}) /* a27 */;{{$}}
+
+    (void)((const std::string_view){{(nullptr)}}) /* a28 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)((const std::string_view){}) /* a28 */;{{$}}
+  }
+
+  // Static Cast
+  {
+    (void)(static_cast<std::string_view>(nullptr)) /* a29 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(static_cast<std::string_view>(std::string_view{})) /* a29 */;{{$}}
+
+    (void)(static_cast<std::string_view>((nullptr))) /* a30 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(static_cast<std::string_view>(std::string_view{})) /* a30 */;{{$}}
+
+    // (void)(static_cast<std::string_view>({nullptr})) /* a31 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(static_cast<std::string_view>({(nullptr)})) /* a32 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(static_cast<const std::string_view>(nullptr)) /* a33 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(static_cast<const std::string_view>(std::string_view{})) /* a33 */;{{$}}
+
+    (void)(static_cast<const std::string_view>((nullptr))) /* a34 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:48: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(static_cast<const std::string_view>(std::string_view{})) /* a34 */;{{$}}
+
+    // (void)(static_cast<const std::string_view>({nullptr})) /* a35 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(static_cast<const std::string_view>({(nullptr)})) /* a36 */;
+    // Braced initializer list does not compile in this context
+  }
+}
+
+void stack_construction() /* b */ {
+  // Copy Initialization
+  {
+    std::string_view b1 = nullptr;
+    // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b1 = {};{{$}}
+
+    std::string_view b2 = (nullptr);
+    // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b2 = {};{{$}}
+
+    const std::string_view b3 = nullptr;
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b3 = {};{{$}}
+
+    const std::string_view b4 = (nullptr);
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b4 = {};{{$}}
+  }
+
+  // Copy List Initialization
+  {
+    std::string_view b5 = {nullptr};
+    // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b5 = { {} };{{$}}
+
+    std::string_view b6 = {(nullptr)};
+    // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b6 = { {} };{{$}}
+
+    const std::string_view b7 = {nullptr};
+    // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b7 = { {} };{{$}}
+
+    const std::string_view b8 = {(nullptr)};
+    // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b8 = { {} };{{$}}
+  }
+
+  // Direct Initialization
+  {
+    std::string_view b9(nullptr);
+    // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b9( {} );{{$}}
+
+    std::string_view b10((nullptr));
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b10( {} );{{$}}
+
+    std::string_view b11({nullptr});
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b11( {} );{{$}}
+
+    std::string_view b12({(nullptr)});
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b12( {} );{{$}}
+
+    const std::string_view b13(nullptr);
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b13( {} );{{$}}
+
+    const std::string_view b14((nullptr));
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b14( {} );{{$}}
+
+    const std::string_view b15({nullptr});
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b15( {} );{{$}}
+
+    const std::string_view b16({(nullptr)});
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b16( {} );{{$}}
+  }
+
+  // Direct List Initialization
+  {
+    std::string_view b17{nullptr};
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b17{ {} };{{$}}
+
+    std::string_view b18{(nullptr)};
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b18{ {} };{{$}}
+
+    std::string_view b19{{nullptr}};
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b19{ {} };{{$}}
+
+    std::string_view b20{{(nullptr)}};
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view b20{ {} };{{$}}
+
+    const std::string_view b21{nullptr};
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b21{ {} };{{$}}
+
+    const std::string_view b22{(nullptr)};
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b22{ {} };{{$}}
+
+    const std::string_view b23{{nullptr}};
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b23{ {} };{{$}}
+
+    const std::string_view b24{{(nullptr)}};
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view b24{ {} };{{$}}
+  }
+}
+
+void field_construction() /* c */ {
+  struct DefaultMemberInitializers {
+    void CopyInitialization();
+
+    std::string_view c1 = nullptr;
+    // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view c1 = {};{{$}}
+
+    std::string_view c2 = (nullptr);
+    // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view c2 = {};{{$}}
+
+    const std::string_view c3 = nullptr;
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view c3 = {};{{$}}
+
+    const std::string_view c4 = (nullptr);
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view c4 = {};{{$}}
+
+    void CopyListInitialization();
+
+    std::string_view c5 = {nullptr};
+    // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view c5 = {};{{$}}
+
+    std::string_view c6 = {(nullptr)};
+    // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view c6 = {};{{$}}
+
+    const std::string_view c7 = {nullptr};
+    // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view c7 = {};{{$}}
+
+    const std::string_view c8 = {(nullptr)};
+    // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view c8 = {};{{$}}
+
+    void DirectListInitialization();
+
+    std::string_view c9{nullptr};
+    // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view c9{};{{$}}
+
+    std::string_view c10{(nullptr)};
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view c10{};{{$}}
+
+    std::string_view c11{{nullptr}};
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view c11{};{{$}}
+
+    std::string_view c12{{(nullptr)}};
+    // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    std::string_view c12{};{{$}}
+
+    const std::string_view c13{nullptr};
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view c13{};{{$}}
+
+    const std::string_view c14{(nullptr)};
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view c14{};{{$}}
+
+    const std::string_view c15{{nullptr}};
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view c15{};{{$}}
+
+    const std::string_view c16{{(nullptr)}};
+    // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    const std::string_view c16{};{{$}}
+  };
+
+  class ConstructorInitializers {
+    ConstructorInitializers()
+        : direct_initialization(),
+
+          c17(nullptr),
+          // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+          // CHECK-FIXES: {{^}}          c17(),{{$}}
+
+          c18((nullptr)),
+          // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+          // CHECK-FIXES: {{^}}          c18(),{{$}}
+
+          c19({nullptr}),
+          // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+          // CHECK-FIXES: {{^}}          c19(),{{$}}
+
+          c20({(nullptr)}),
+          // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+          // CHECK-FIXES: {{^}}          c20(),{{$}}
+
+          direct_list_initialization(),
+
+          c21{nullptr},
+          // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+          // CHECK-FIXES: {{^}}          c21{},{{$}}
+
+          c22{(nullptr)},
+          // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+          // CHECK-FIXES: {{^}}          c22{},{{$}}
+
+          c23{{nullptr}},
+          // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+          // CHECK-FIXES: {{^}}          c23{},{{$}}
+
+          c24{{(nullptr)}},
+          // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+          // CHECK-FIXES: {{^}}          c24{},{{$}}
+
+          end_of_list() {}
+
+    std::nullptr_t direct_initialization;
+    std::string_view c17;
+    std::string_view c18;
+    std::string_view c19;
+    std::string_view c20;
+    std::nullptr_t direct_list_initialization;
+    std::string_view c21;
+    std::string_view c22;
+    std::string_view c23;
+    std::string_view c24;
+    std::nullptr_t end_of_list;
+  };
+}
+
+void default_argument_construction() /* d */ {
+  // Copy Initialization
+  {
+    void d1(std::string_view sv = nullptr);
+    // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    void d1(std::string_view sv = {});{{$}}
+
+    void d2(std::string_view sv = (nullptr));
+    // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    void d2(std::string_view sv = {});{{$}}
+
+    void d3(const std::string_view sv = nullptr);
+    // CHECK-MESSAGES: :[[@LINE-1]]:41: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    void d3(const std::string_view sv = {});{{$}}
+
+    void d4(const std::string_view sv = (nullptr));
+    // CHECK-MESSAGES: :[[@LINE-1]]:41: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    void d4(const std::string_view sv = {});{{$}}
+  }
+
+  // Copy List Initialization
+  {
+    void d5(std::string_view sv = {nullptr});
+    // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    void d5(std::string_view sv = {});{{$}}
+
+    void d6(std::string_view sv = {(nullptr)});
+    // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    void d6(std::string_view sv = {});{{$}}
+
+    void d7(const std::string_view sv = {nullptr});
+    // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    void d7(const std::string_view sv = {});{{$}}
+
+    void d8(const std::string_view sv = {(nullptr)});
+    // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    void d8(const std::string_view sv = {});{{$}}
+  }
+}
+
+void heap_construction() /* e */ {
+  // Direct Initialization
+  {
+    (void)(new std::string_view(nullptr)) /* e1 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new std::string_view()) /* e1 */;{{$}}
+
+    (void)(new std::string_view((nullptr))) /* e2 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new std::string_view()) /* e2 */;{{$}}
+
+    (void)(new std::string_view({nullptr})) /* e3 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new std::string_view()) /* e3 */;{{$}}
+
+    (void)(new std::string_view({(nullptr)})) /* e4 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new std::string_view()) /* e4 */;{{$}}
+
+    (void)(new const std::string_view(nullptr)) /* e5 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new const std::string_view()) /* e5 */;{{$}}
+
+    (void)(new const std::string_view((nullptr))) /* e6 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new const std::string_view()) /* e6 */;{{$}}
+
+    (void)(new const std::string_view({nullptr})) /* e7 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new const std::string_view()) /* e7 */;{{$}}
+
+    (void)(new const std::string_view({(nullptr)})) /* e8 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new const std::string_view()) /* e8 */;{{$}}
+  }
+
+  // Direct List Initialization
+  {
+    (void)(new std::string_view{nullptr}) /* e9 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new std::string_view{}) /* e9 */;{{$}}
+
+    (void)(new std::string_view{(nullptr)}) /* e10 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new std::string_view{}) /* e10 */;{{$}}
+
+    (void)(new std::string_view{{nullptr}}) /* e11 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new std::string_view{}) /* e11 */;{{$}}
+
+    (void)(new std::string_view{{(nullptr)}}) /* e12 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new std::string_view{}) /* e12 */;{{$}}
+
+    (void)(new const std::string_view{nullptr}) /* e13 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new const std::string_view{}) /* e13 */;{{$}}
+
+    (void)(new const std::string_view{(nullptr)}) /* e14 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new const std::string_view{}) /* e14 */;{{$}}
+
+    (void)(new const std::string_view{{nullptr}}) /* e15 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new const std::string_view{}) /* e15 */;{{$}}
+
+    (void)(new const std::string_view{{(nullptr)}}) /* e16 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:39: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    (void)(new const std::string_view{}) /* e16 */;{{$}}
+  }
+}
+
+void function_invocation() /* f */ {
+  // Single Argument
+  {
+    function(nullptr) /* f1 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    function({}) /* f1 */;{{$}}
+
+    function((nullptr)) /* f2 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    function({}) /* f2 */;{{$}}
+
+    function({nullptr}) /* f3 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    function({}) /* f3 */;{{$}}
+
+    function({(nullptr)}) /* f4 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    function({}) /* f4 */;{{$}}
+  }
+
+  // Multiple Argument
+  {
+    function(nullptr, nullptr) /* f5 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-MESSAGES: :[[@LINE-2]]:23: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    function({}, {}) /* f5 */;{{$}}
+
+    function((nullptr), (nullptr)) /* f6 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-MESSAGES: :[[@LINE-2]]:25: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    function({}, {}) /* f6 */;{{$}}
+
+    function({nullptr}, {nullptr}) /* f7 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-MESSAGES: :[[@LINE-2]]:26: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    function({}, {}) /* f7 */;{{$}}
+
+    function({(nullptr)}, {(nullptr)}) /* f8 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-MESSAGES: :[[@LINE-2]]:28: warning: constructing basic_string_view from null is undefined; replace with the default constructor
+    // CHECK-FIXES: {{^}}    function({}, {}) /* f8 */;{{$}}
+  }
+}
+
+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 */;{{$}}
+
+  sv = (nullptr) /* g2 */;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: assignment to basic_string_view from null is undefined; replace with the default constructor
+  // CHECK-FIXES: {{^}}  sv = {} /* g2 */;{{$}}
+
+  sv = {nullptr} /* g3 */;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: assignment to basic_string_view from null is undefined; replace with the default constructor
+  // CHECK-FIXES: {{^}}  sv = {} /* g3 */;{{$}}
+
+  sv = {(nullptr)} /* g4 */;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: assignment to basic_string_view from null is undefined; replace with the default constructor
+  // CHECK-FIXES: {{^}}  sv = {} /* g4 */;{{$}}
+}
+
+void pointer_assignment(std::string_view *sv_ptr) /* h */ {
+  *sv_ptr = nullptr /* h1 */;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: assignment to basic_string_view from null is undefined; replace with the default constructor
+  // CHECK-FIXES: {{^}}  *sv_ptr = {} /* h1 */;{{$}}
+
+  *sv_ptr = (nullptr) /* h2 */;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: assignment to basic_string_view from null is undefined; replace with the default constructor
+  // CHECK-FIXES: {{^}}  *sv_ptr = {} /* h2 */;{{$}}
+
+  *sv_ptr = {nullptr} /* h3 */;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: assignment to basic_string_view from null is undefined; replace with the default constructor
+  // CHECK-FIXES: {{^}}  *sv_ptr = {} /* h3 */;{{$}}
+
+  *sv_ptr = {(nullptr)} /* h4 */;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: assignment to basic_string_view from null is undefined; replace with the default constructor
+  // CHECK-FIXES: {{^}}  *sv_ptr = {} /* h4 */;{{$}}
+}
+
+void lesser_comparison(std::string_view sv) /* i */ {
+  // Without Equality
+  {
+    (void)(sv < nullptr) /* i1 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(sv < "") /* i1 */;{{$}}
+
+    (void)(sv < (nullptr)) /* i2 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(sv < "") /* i2 */;{{$}}
+
+    // (void)(sv < {nullptr}) /* i3 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(sv < {(nullptr)}) /* i4 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr < sv) /* i5 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" < sv) /* i5 */;{{$}}
+
+    (void)((nullptr) < sv) /* i6 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" < sv) /* i6 */;{{$}}
+
+    // (void)({nullptr} < sv) /* i7 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} < sv) /* i8*/;
+    // Braced initializer list does not compile in this context
+  }
+
+  // With Equality
+  {
+    (void)(sv <= nullptr) /* i9 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(sv <= "") /* i9 */;{{$}}
+
+    (void)(sv <= (nullptr)) /* i10 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(sv <= "") /* i10 */;{{$}}
+
+    // (void)(sv <= {nullptr}) /* i11 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(sv <= {(nullptr)}) /* i12 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr <= sv) /* i13 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" <= sv) /* i13 */;{{$}}
+
+    (void)((nullptr) <= sv) /* i14 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" <= sv) /* i14 */;{{$}}
+
+    // (void)({nullptr} <= sv) /* i15 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} <= sv) /* i16 */;
+    // Braced initializer list does not compile in this context
+  }
+}
+
+void pointer_lesser_comparison(std::string_view *sv_ptr) /* j */ {
+  // Without Equality
+  {
+    (void)(*sv_ptr < nullptr) /* j1 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(*sv_ptr < "") /* j1 */;{{$}}
+
+    (void)(*sv_ptr < (nullptr)) /* j2 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(*sv_ptr < "") /* j2 */;{{$}}
+
+    // (void)(*sv_ptr < {nullptr}) /* j3 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(*sv_ptr < {(nullptr)}) /* j4 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr < *sv_ptr) /* j5 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" < *sv_ptr) /* j5 */;{{$}}
+
+    (void)((nullptr) < *sv_ptr) /* j6 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" < *sv_ptr) /* j6 */;{{$}}
+
+    // (void)({nullptr} < *sv_ptr) /* j7 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} < *sv_ptr) /* j8 */;
+    // Braced initializer list does not compile in this context
+  }
+
+  // With Equality
+  {
+    (void)(*sv_ptr <= nullptr) /* j9 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(*sv_ptr <= "") /* j9 */;{{$}}
+
+    (void)(*sv_ptr <= (nullptr)) /* j10 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(*sv_ptr <= "") /* j10 */;{{$}}
+
+    // (void)(*sv_ptr <= {nullptr}) /* j11 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(*sv_ptr <= {(nullptr)}) /* j12 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr <= *sv_ptr) /* j13 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" <= *sv_ptr) /* j13 */;{{$}}
+
+    (void)((nullptr) <= *sv_ptr) /* j14 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" <= *sv_ptr) /* j14 */;{{$}}
+
+    // (void)({nullptr} <= *sv_ptr) /* j15 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} <= *sv_ptr) /* j16 */;
+    // Braced initializer list does not compile in this context
+  }
+}
+
+void greater_comparison(std::string_view sv) /* k */ {
+  // Without Equality
+  {
+    (void)(sv > nullptr) /* k1 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(sv > "") /* k1 */;{{$}}
+
+    (void)(sv > (nullptr)) /* k2 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(sv > "") /* k2 */;{{$}}
+
+    // (void)(sv > {nullptr}) /* k3 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(sv > {(nullptr)}) /* k4 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr > sv) /* k5 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" > sv) /* k5 */;{{$}}
+
+    (void)((nullptr) > sv) /* k6 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" > sv) /* k6 */;{{$}}
+
+    // (void)({nullptr} > sv) /* k7 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} > sv) /* k8 */;
+    // Braced initializer list does not compile in this context
+  }
+
+  // With Equality
+  {
+    (void)(sv >= nullptr) /* k9 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(sv >= "") /* k9 */;{{$}}
+
+    (void)(sv >= (nullptr)) /* k10 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(sv >= "") /* k10 */;{{$}}
+
+    // (void)(sv >= {nullptr}) /* k11 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(sv >= {(nullptr)}) /* k12 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr >= sv) /* k13 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" >= sv) /* k13 */;{{$}}
+
+    (void)((nullptr) >= sv) /* k14 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" >= sv) /* k14 */;{{$}}
+
+    // (void)({nullptr} >= sv) /* k15 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} >= sv) /* k16 */;
+    // Braced initializer list does not compile in this context
+  }
+}
+
+void pointer_greater_comparison(std::string_view *sv_ptr) /* l */ {
+  // Without Equality
+  {
+    (void)(*sv_ptr > nullptr) /* l1 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(*sv_ptr > "") /* l1 */;{{$}}
+
+    (void)(*sv_ptr > (nullptr)) /* l2 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(*sv_ptr > "") /* l2 */;{{$}}
+
+    // (void)(*sv_ptr > {nullptr}) /* l3 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(*sv_ptr > {(nullptr)}) /* l4 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr > *sv_ptr) /* l5 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" > *sv_ptr) /* l5 */;{{$}}
+
+    (void)((nullptr) > *sv_ptr) /* l6 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" > *sv_ptr) /* l6 */;{{$}}
+
+    // (void)({nullptr} > *sv_ptr) /* l7 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} > *sv_ptr) /* l8 */;
+    // Braced initializer list does not compile in this context
+  }
+
+  // With Equality
+  {
+    (void)(*sv_ptr >= nullptr) /* l9 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(*sv_ptr >= "") /* l9 */;{{$}}
+
+    (void)(*sv_ptr >= (nullptr)) /* l10 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)(*sv_ptr >= "") /* l10 */;{{$}}
+
+    // (void)(*sv_ptr >= {nullptr}) /* l11 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(*sv_ptr >= {(nullptr)}) /* l12 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr >= *sv_ptr) /* l13 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" >= *sv_ptr) /* l13 */;{{$}}
+
+    (void)((nullptr) >= *sv_ptr) /* l14 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the empty string
+    // CHECK-FIXES: {{^}}    (void)("" >= *sv_ptr) /* l14 */;{{$}}
+
+    // (void)({nullptr} >= *sv_ptr) /* l15 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} >= *sv_ptr) /* l16 */;
+    // Braced initializer list does not compile in this context
+  }
+}
+
+void equality_comparison(std::string_view sv) /* m */ {
+  // Empty
+  {
+    (void)(sv == nullptr) /* m1 */;
+    // 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 */;{{$}}
+
+    (void)(sv == (nullptr)) /* m2 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(sv.empty()) /* m2 */;{{$}}
+
+    // (void)(sv == {nullptr}) /* m3 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(sv == {(nullptr)}) /* m4 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr == sv) /* m5 */;
+    // 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 */;{{$}}
+
+    (void)((nullptr) == sv) /* m6 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(sv.empty()) /* m6 */;{{$}}
+
+    // (void)({nullptr} == sv) /* m7 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} == sv) /* m8 */;
+    // Braced initializer list does not compile in this context
+  }
+
+  // Non-Empty
+  {
+    (void)(sv != nullptr) /* m9 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(!sv.empty()) /* m9 */;{{$}}
+
+    (void)(sv != (nullptr)) /* m10 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(!sv.empty()) /* m10 */;{{$}}
+
+    // (void)(sv != {nullptr}) /* m11 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(sv != {(nullptr)}) /* m12 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr != sv) /* m13 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(!sv.empty()) /* m13 */;{{$}}
+
+    (void)((nullptr) != sv) /* m14 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(!sv.empty()) /* m14 */;{{$}}
+
+    // (void)({nullptr} != sv) /* m15 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} != sv) /* m16 */;
+    // Braced initializer list does not compile in this context
+  }
+}
+
+void pointer_equality_comparison(std::string_view *sv_ptr) /* n */ {
+  // Empty
+  {
+    (void)(*sv_ptr == 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_ptr->empty()) /* n1 */;{{$}}
+
+    (void)(*sv_ptr == (nullptr)) /* n2 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(sv_ptr->empty()) /* n2 */;{{$}}
+
+    // (void)(*sv_ptr == {nullptr}) /* n3 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(*sv_ptr == {(nullptr)}) /* n4 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr == *sv_ptr) /* n5 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(sv_ptr->empty()) /* n5 */;{{$}}
+
+    (void)((nullptr) == *sv_ptr) /* n6 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(sv_ptr->empty()) /* n6 */;{{$}}
+
+    // (void)({nullptr} == *sv_ptr) /* n7 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} == *sv_ptr) /* n8 */;
+    // Braced initializer list does not compile in this context
+  }
+
+  // Non-Empty
+  {
+    (void)(*sv_ptr != nullptr) /* n9 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(!sv_ptr->empty()) /* n9 */;{{$}}
+
+    (void)(*sv_ptr != (nullptr)) /* n10 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(!sv_ptr->empty()) /* n10 */;{{$}}
+
+    // (void)(*sv_ptr != {nullptr}) /* n11 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)(*sv_ptr != {(nullptr)}) /* n12 */;
+    // Braced initializer list does not compile in this context
+
+    (void)(nullptr != *sv_ptr) /* n13 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(!sv_ptr->empty()) /* n13 */;{{$}}
+
+    (void)((nullptr) != *sv_ptr) /* n14 */;
+    // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: comparing basic_string_view to null is undefined; replace with the emptiness query
+    // CHECK-FIXES: {{^}}    (void)(!sv_ptr->empty()) /* n14 */;{{$}}
+
+    // (void)({nullptr} != *sv_ptr) /* n15 */;
+    // Braced initializer list does not compile in this context
+
+    // (void)({(nullptr)} != *sv_ptr) /* n16 */;
+    // Braced initializer list does not compile in this context
+  }
+}