[ASTImporter] Add support for importing GenericSelectionExpr AST nodes.

[tmroeder]

Summary

This allows ASTs to be merged when they contain GenericSelectionExpr
nodes (this is _Generic from C11). This is needed, for example, for
CTU analysis of C code that makes use of _Generic, like the Linux
kernel.

The node is already supported in the AST, but it didn't have a matcher
in ASTMatchers. So, this change adds the matcher and adds support to
ASTImporter. Additionally, this change adds support for structural
equivalence of _Generic in the AST.

[tmroeder]

Fix a typo in the summary.

[shafik]

ASTImporter changes looks good to me.

clang/lib/AST/ASTImporter.cpp

6550

nitpick context -> ToCtx to be consistent with other code.

[tmroeder]

Renamed context to ToCtx as suggested.

[martong]

It might be worth to extend StmtComparer as well with this Expr. I mean, probably two selections exprs should be considered equal if their assoc exprs are equal too...

[martong]

In D92600#2433263, @martong wrote:

It might be worth to extend StmtComparer as well with this Expr. I mean, probably two selections exprs should be considered equal if their assoc exprs are equal too...

@teemperor , WDYT?

[teemperor]

Having the comparison code would be nice. The custom types in the associated types aren't compared by the generic code, so an overload like this in the StmtComparer class should be enough:

bool IsStmtEquivalent(const GenericSelectionExpr *E1, const GenericSelectionExpr *E2) {
  for (auto Pair : zip_longest(E1->getAssocTypeSourceInfos(),
                               E2->getAssocTypeSourceInfos())) {
    Optional<TypeSourceInfo *> Child1 = std::get<0>(Pair);
    Optional<TypeSourceInfo *> Child2 = std::get<1>(Pair);
    // Different number of associated types.
    if (!Child1 || !Child2)
      return false;

    if (!IsStructurallyEquivalent(Context, (*Child1)->getType(),
                                  (*Child2)->getType()))
      return false;
  }
  return true;
}

[aaron.ballman]

clang/include/clang/ASTMatchers/ASTMatchers.h

2366

Do we have a use case for adding this as an AST matcher? For instance, one of the first things I'd want to do with such a matcher is traverse down to the association list, but I don't think that's possible currently. Should we add all of the AST functionality or just wait until there's a concrete use case and add the AST matchers bits at that point?

clang/lib/AST/ASTImporter.cpp

6534

[tmroeder]

clang/include/clang/ASTMatchers/ASTMatchers.h

2366

I mostly did this because that's what I did in the previous case from Feb 2019: reviews.llvm.org/D58292, for ChooseExpr, and I was cribbing off my old code.

However, on further reflection, I remembered that this patch actually removes a case that was locally defining this matcher already: see the removed lines in clang/lib/Analysis/ExprMutationAnalyzer.cpp in this patch. So, I think that is enough of a case for adding this.

[tmroeder]

Added structural equivalence and a few tests for it.

[tmroeder]

Fixed the clang-tidy warning as suggested.

[aaron.ballman]

clang/include/clang/ASTMatchers/ASTMatchers.h

2366

Okay, fair enough. Thanks!

clang/test/ASTMerge/generic-selection-expr/Inputs/generic.c

2

Should we also have a C++ test for a result-dependent use of _Generic? (We support use of _Generic in C++ as an extension.)

clang/unittests/AST/StructuralEquivalenceTest.cpp

1601

Should we add a structural equivalence test for a dependent result type in C++?

[tmroeder]

Added C++ tests for result-dependent uses, and added that fact to the description as well.

[tmroeder]

clang/test/ASTMerge/generic-selection-expr/Inputs/generic.c

2

Added in a new file test.cpp

[aaron.ballman]

LGTM!

[tmroeder]

@aaron.ballman It looks like those template tests fail on x64 windows; this is a problem that came up with D58292 as well. It ended up getting rolled back because template-based tests failed on windows, and I had to remove the tests and resubmit.

I'm not sure what the right way is to fix these tests: skip them on Windows? If so, then can you please tell me how to do that?

[tmroeder]

Moved the result-dependent tests into a different test class, one that explicitly uses templates already.

[martong]

LGTM!

[aaron.ballman]

In D92600#2443716, @tmroeder wrote:

@aaron.ballman It looks like those template tests fail on x64 windows; this is a problem that came up with D58292 as well. It ended up getting rolled back because template-based tests failed on windows, and I had to remove the tests and resubmit.

I'm not sure what the right way is to fix these tests: skip them on Windows? If so, then can you please tell me how to do that?

Looking at the changes you made, I'm not certain why one test would work and one test would fail -- however, the usual issue with template tests on Windows is that the default behavior on Windows is to match the MSVC template behavior and so you sometimes need to pass -fno-delayed-template-parsing to those tests to get the same behavior as on other platforms.

[martong]

I wouldn't worry much about the ASTMerge tests, those are mostly legacy and not actively used nowadays. (At one point we were thinking even to remove them because we could got rid of the ASTMergeAction which is exclusively used for testing.)
The main test infrastructure for the ASTImporter is in the unittests. Those tests are exercised even with -fdelayed-template-parsing and with -fms-compatibility. So I am fine with marking the ASTMerge tests with XFAIL on windows.

[tmroeder]

Fixed a formatting problem brought up by clang-format.

[tmroeder]

In D92600#2445612, @martong wrote:

I wouldn't worry much about the ASTMerge tests, those are mostly legacy and not actively used nowadays. (At one point we were thinking even to remove them because we could got rid of the ASTMergeAction which is exclusively used for testing.)
The main test infrastructure for the ASTImporter is in the unittests. Those tests are exercised even with -fdelayed-template-parsing and with -fms-compatibility. So I am fine with marking the ASTMerge tests with XFAIL on windows.

Sorry for the confusion: I uploaded a change to try to fix the real test failure and there turned out to be a clang-format problem in my ASTMerge tests as well. The problems I was referring to were not in ASTMerge but rather from the unit tests in a previous diff: https://buildkite.com/llvm-project/premerge-checks/builds/19205#4f1d9b0a-16bf-401d-b07e-cceb29612fd0

Is there a way to mark unit tests as failing on a particular architecture?

The answer might not matter, because I've moved those unit tests into a different unit-test class, one that only has templates, and I hope that that means it will work correctly or be skipped correct in cases where template processing is a problem.

I haven't so far been able to get my Windows box to build LLVM (still working through some problems like atlbase.h), so I'll have to wait for the CI to tell me if x64 windows works with the diff I just uploaded: it fixes the trivial clang-format problem in the ASTMerge tests and it keeps the Structural Equivalence unit tests in the unit-test class I just mentioned.

[tmroeder]

Rebased to the latest head version.

[tmroeder]

I think I've fixed the Windows tests; I got a build working on a Windows machine and was able to debug.

It looks like the problem is again due to delayed template parsing: the templatized functions in the test both came out as nullptr. So, I added a check for nullptr in the case that expects the two values to be different. The test only tries to compare them if at least one is not null.

[tmroeder]

Removed an unintentionally added extra line.

[martong]

Thanks for the update. I checked it, still looks good to me.

Some notes in parenthesis:

It looks like the problem is again due to delayed template parsing: the templatized functions in the test both came out as nullptr. So, I added a check for nullptr in the case that expects the two values to be different. The test only tries to compare them if at least one is not null.

Ideally, we should have parameterized structural equivalency tests (similarly to what we have in ASTImporterTest with INSTANTIATE_TEST_CASE_P). The parameters could be the compiler options, i.e. in this case I think we would be able to explicitly emit the delayed template parsing option. Anyway, let's keep that as a future update if we bump into more similar cases.

[tmroeder]

In D92600#2452174, @martong wrote:

Thanks for the update. I checked it, still looks good to me.

Some notes in parenthesis:

It looks like the problem is again due to delayed template parsing: the templatized functions in the test both came out as nullptr. So, I added a check for nullptr in the case that expects the two values to be different. The test only tries to compare them if at least one is not null.

Ideally, we should have parameterized structural equivalency tests (similarly to what we have in ASTImporterTest with INSTANTIATE_TEST_CASE_P). The parameters could be the compiler options, i.e. in this case I think we would be able to explicitly emit the delayed template parsing option. Anyway, let's keep that as a future update if we bump into more similar cases.

Thanks! Unfortunately, my fix didn't solve the whole problem on Windows, because I forgot to build with assertions when repro'ing the failure, so I fixed one problem but not the other. I'm now working on fixing the test under assertions as well.

[tmroeder]

Change the DeclMatcher.h test code to expose the ability to not assert on null Nodes from a match.

This allows the tests for GenericSelectionExpr to handle the null case on Windows themselves without crashing, and to still work correctly and test the appropriate functionality on Linux.

[tmroeder]

In D92600#2453124, @tmroeder wrote:

Change the DeclMatcher.h test code to expose the ability to not assert on null Nodes from a match.

This allows the tests for GenericSelectionExpr to handle the null case on Windows themselves without crashing, and to still work correctly and test the appropriate functionality on Linux.

It looks like this change finally fixed the Windows tests that I was breaking. However, I'm now touching new parts of the test framework to make this work. Please take a look at and let me know what you think.

[tmroeder]

Update to the latest head. No changes from previous diff.

[martong]

clang/unittests/AST/StructuralEquivalenceTest.cpp

1645–1651

Change the DeclMatcher.h test code to expose the ability to not assert on null Nodes from a match.

The original idea was to assert in the DeclMatcher to indicate a failure in the test itself. In the past it happened to me often that I wrote a wrong matcher and that assertion indicated it and that was really helpful.

So, I'd suggest an alternative approach instead of this change in the DeclMatcher: Try to instantiate the template function itself, so even if the delayed template instantiation option is set, the compiler must instantiate.

Related code in other ASTImporter tests:
https://github.com/llvm/llvm-project/blob/bd0709266911bce2f1e8a875f9ed49d56953f323/clang/unittests/AST/ASTImporterGenericRedeclTest.cpp#L60

[tmroeder]

Explicitly instantiate the templates in the structural-equivalence test.

This seems to work correctly on Windows, and it avoids the need for the extra hooks in the test framework. So, this diff removes those hooks as well as the nullptr test. The latter is no longer needed either because the templates get explicitly instantiated, even under delayed template expansion.

[martong]

Thanks for your work, I am glad that finally the Window bug is fixed with a simple solution.

[tmroeder]

Rebase to the latest head, mostly to force the CI infrastructure to run again now that it is said to work again: https://github.com/google/llvm-premerge-checks/issues/268#issuecomment-745979134.

[tmroeder]

Looks like I missed the transition of my credentials from SVN from github, so I can't currently commit this.

How do I go about getting those credentials restored?

[tmroeder]

In D92600#2458715, @tmroeder wrote:

Looks like I missed the transition of my credentials from SVN from github, so I can't currently commit this.

How do I go about getting those credentials restored?

Never mind, I found it in the Developer Policy document

clang/docs/LibASTMatchersReference.html

 <tr><td colspan="4" class="doc" id="forStmt0"><pre>Matches for statements.
 
 Example matches 'for (;;) {}'
   for (;;) {}
   int i[] =  {1, 2, 3}; for (auto a : i);
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('genericSelectionExpr0')"><a name="genericSelectionExpr0Anchor">genericSelectionExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1GenericSelectionExpr.html">GenericSelectionExpr</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="genericSelectionExpr0"><pre>Matches C11 _Generic expression.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('gnuNullExpr0')"><a name="gnuNullExpr0Anchor">gnuNullExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1GNUNullExpr.html">GNUNullExpr</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="gnuNullExpr0"><pre>Matches GNU __null expression.
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('gotoStmt0')"><a name="gotoStmt0Anchor">gotoStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1GotoStmt.html">GotoStmt</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="gotoStmt0"><pre>Matches goto statements.
 

clang/include/clang/ASTMatchers/ASTMatchers.h

 /// Matches GNU __builtin_choose_expr.
 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr>
     chooseExpr;
 
 /// Matches GNU __null expression.
 extern const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr>
     gnuNullExpr;
 
+/// Matches C11 _Generic expression.
+extern const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
+    genericSelectionExpr;
+
 /// Matches atomic builtins.
 /// Example matches __atomic_load_n(ptr, 1)
 /// \code
 ///   void foo() { int *ptr; __atomic_load_n(ptr, 1); }
 /// \endcode
 extern const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr;
 
 /// Matches statement expression (GNU extension).

clang/lib/AST/ASTImporter.cpp

public:
     ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
     ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
 
     // Importing expressions
     ExpectedStmt VisitExpr(Expr *E);
     ExpectedStmt VisitVAArgExpr(VAArgExpr *E);
     ExpectedStmt VisitChooseExpr(ChooseExpr *E);
     ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E);
+    ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E);
     ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E);
     ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E);
     ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
     ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E);
     ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
     ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E);
     ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E);
     ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E);
ExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
 
   ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc());
   if (!BeginLocOrErr)
     return BeginLocOrErr.takeError();
 
   return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr);
 }
 
+ExpectedStmt
+ASTNodeImporter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
+  Error Err = Error::success();
+  auto ToGenericLoc = importChecked(Err, E->getGenericLoc());
+  auto *ToControllingExpr = importChecked(Err, E->getControllingExpr());
+  auto ToDefaultLoc = importChecked(Err, E->getDefaultLoc());
+  auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
+  if (Err)
+    return std::move(Err);
+
+  ArrayRef<const TypeSourceInfo *> FromAssocTypes(E->getAssocTypeSourceInfos());
+  SmallVector<TypeSourceInfo *, 1> ToAssocTypes(FromAssocTypes.size());
+  if (Error Err = ImportContainerChecked(FromAssocTypes, ToAssocTypes))
+    return std::move(Err);
+
+  ArrayRef<const Expr *> FromAssocExprs(E->getAssocExprs());
+  SmallVector<Expr *, 1> ToAssocExprs(FromAssocExprs.size());
+  if (Error Err = ImportContainerChecked(FromAssocExprs, ToAssocExprs))
+    return std::move(Err);
+
+  const ASTContext &ToCtx = Importer.getToContext();
+  if (E->isResultDependent()) {
+    return GenericSelectionExpr::Create(
+        ToCtx, ToGenericLoc, ToControllingExpr,
+        llvm::makeArrayRef(ToAssocTypes), llvm::makeArrayRef(ToAssocExprs),
+        ToDefaultLoc, ToRParenLoc, E->containsUnexpandedParameterPack());
+  }
+
+  return GenericSelectionExpr::Create(
+      ToCtx, ToGenericLoc, ToControllingExpr, llvm::makeArrayRef(ToAssocTypes),
+      llvm::makeArrayRef(ToAssocExprs), ToDefaultLoc, ToRParenLoc,
+      E->containsUnexpandedParameterPack(), E->getResultIndex());
+}
+
 ExpectedStmt ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
 
   Error Err = Error::success();
   auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
   auto ToType = importChecked(Err, E->getType());
   auto ToFunctionName = importChecked(Err, E->getFunctionName());
   if (Err)
     return std::move(Err);

clang/lib/AST/ASTStructuralEquivalence.cpp

bool IsStmtEquivalent(const ExpressionTraitExpr *E1,
                         const ExpressionTraitExpr *E2) {
     return E1->getTrait() == E2->getTrait() && E1->getValue() == E2->getValue();
   }
 
   bool IsStmtEquivalent(const FloatingLiteral *E1, const FloatingLiteral *E2) {
     return E1->isExact() == E2->isExact() && E1->getValue() == E2->getValue();
   }
 
+  bool IsStmtEquivalent(const GenericSelectionExpr *E1,
+                        const GenericSelectionExpr *E2) {
+    for (auto Pair : zip_longest(E1->getAssocTypeSourceInfos(),
+                                 E2->getAssocTypeSourceInfos())) {
+      Optional<TypeSourceInfo *> Child1 = std::get<0>(Pair);
+      Optional<TypeSourceInfo *> Child2 = std::get<1>(Pair);
+      // Skip this case if there are a different number of associated types.
+      if (!Child1 || !Child2)
+        return false;
+
+      if (!IsStructurallyEquivalent(Context, (*Child1)->getType(),
+                                    (*Child2)->getType()))
+        return false;
+    }
+
+    return true;
+  }
+
   bool IsStmtEquivalent(const ImplicitCastExpr *CastE1,
                         const ImplicitCastExpr *CastE2) {
     return IsStructurallyEquivalent(Context, CastE1->getType(),
                                     CastE2->getType());
   }
 
   bool IsStmtEquivalent(const IntegerLiteral *E1, const IntegerLiteral *E2) {
     return E1->getValue() == E2->getValue();

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

 const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
     userDefinedLiteral;
 const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
     compoundLiteralExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
     cxxNullPtrLiteralExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr> chooseExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr> gnuNullExpr;
+const internal::VariadicDynCastAllOfMatcher<Stmt, GenericSelectionExpr>
+    genericSelectionExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
     binaryOperator;
 const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator> unaryOperator;
 const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
     conditionalOperator;
 const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryConditionalOperator>

clang/lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(forField);
   REGISTER_MATCHER(forFunction);
   REGISTER_MATCHER(forStmt);
   REGISTER_MATCHER(friendDecl);
   REGISTER_MATCHER(functionDecl);
   REGISTER_MATCHER(functionProtoType);
   REGISTER_MATCHER(functionTemplateDecl);
   REGISTER_MATCHER(functionType);
+  REGISTER_MATCHER(genericSelectionExpr);
   REGISTER_MATCHER(gnuNullExpr);
   REGISTER_MATCHER(gotoStmt);
   REGISTER_MATCHER(has);
   REGISTER_MATCHER(hasAncestor);
   REGISTER_MATCHER(hasAnyArgument);
   REGISTER_MATCHER(hasAnyBase);
   REGISTER_MATCHER(hasAnyClause);
   REGISTER_MATCHER(hasAnyConstructorInitializer);

clang/lib/Analysis/ExprMutationAnalyzer.cpp

 
 const ast_matchers::internal::VariadicDynCastAllOfMatcher<Stmt, CXXTypeidExpr>
     cxxTypeidExpr;
 
 AST_MATCHER(CXXTypeidExpr, isPotentiallyEvaluated) {
   return Node.isPotentiallyEvaluated();
 }
 
-const ast_matchers::internal::VariadicDynCastAllOfMatcher<Stmt,
-                                                          GenericSelectionExpr>
-    genericSelectionExpr;
-
 AST_MATCHER_P(GenericSelectionExpr, hasControllingExpr,
               ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
   return InnerMatcher.matches(*Node.getControllingExpr(), Finder, Builder);
 }
 
 const auto nonConstReferenceType = [] {
   return hasUnqualifiedDesugaredType(
       referenceType(pointee(unless(isConstQualified()))));

clang/test/ASTMerge/generic-selection-expr/Inputs/generic.c

+void f() {
+  int x;
+  float y;
+  _Static_assert(_Generic(x, float : 0, int : 1), "Incorrect semantics of _Generic");
+  _Static_assert(_Generic(y, float : 1, int : 0), "Incorrect semantics of _Generic");
+}

clang/test/ASTMerge/generic-selection-expr/Inputs/generic.cpp

+template <typename T>
+void f() {
+  T x;
+  _Static_assert(_Generic(x, float : 0, int : 1), "Incorrect semantics of _Generic");
+}

clang/test/ASTMerge/generic-selection-expr/test.c

+// RUN: %clang_cc1 -std=c11 -emit-pch -o %t.ast %S/Inputs/generic.c
+// RUN: %clang_cc1 -std=c11 -ast-merge %t.ast -fsyntax-only -verify %s
+// expected-no-diagnostics

clang/test/ASTMerge/generic-selection-expr/test.cpp

+// RUN: %clang_cc1 -std=c++03 -emit-pch -o %t.ast %S/Inputs/generic.cpp
+// RUN: %clang_cc1 -std=c++03 -ast-merge %t.ast -fsyntax-only -verify %s
+// expected-no-diagnostics

clang/unittests/AST/ASTImporterTest.cpp

 
 TEST_P(ImportExpr, ImportGNUNullExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { (void)__null; }", Lang_CXX03, "",
              Lang_CXX03, Verifier,
              functionDecl(hasDescendant(gnuNullExpr(hasType(isInteger())))));
 }
 
+TEST_P(ImportExpr, ImportGenericSelectionExpr) {
+  MatchVerifier<Decl> Verifier;
+
+  testImport(
+      "void declToImport() { int x; (void)_Generic(x, int: 0, float: 1); }",
+      Lang_C99, "", Lang_C99, Verifier,
+      functionDecl(hasDescendant(genericSelectionExpr())));
+}
+
 TEST_P(ImportExpr, ImportCXXNullPtrLiteralExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() { (void)nullptr; }",
       Lang_CXX11, "", Lang_CXX11, Verifier,
       functionDecl(hasDescendant(cxxNullPtrLiteralExpr())));
 }
 
TEST_P(ASTImporterOptionSpecificTestBase, ImportChooseExpr) {
   const ChooseExpr *ToChooseExpr = selectFirst<ChooseExpr>("choose", ToResults);
   ASSERT_TRUE(ToChooseExpr);
 
   EXPECT_EQ(FromChooseExpr->isConditionTrue(), ToChooseExpr->isConditionTrue());
   EXPECT_EQ(FromChooseExpr->isConditionDependent(),
             ToChooseExpr->isConditionDependent());
 }
 
+TEST_P(ASTImporterOptionSpecificTestBase, ImportGenericSelectionExpr) {
+  Decl *From, *To;
+  std::tie(From, To) = getImportedDecl(
+      R"(
+      int declToImport() {
+        int x;
+        return _Generic(x, int: 0, default: 1);
+      }
+      )",
+      Lang_C99, "", Lang_C99);
+
+  auto ToResults =
+      match(genericSelectionExpr().bind("expr"), To->getASTContext());
+  auto FromResults =
+      match(genericSelectionExpr().bind("expr"), From->getASTContext());
+
+  const GenericSelectionExpr *FromGenericSelectionExpr =
+      selectFirst<GenericSelectionExpr>("expr", FromResults);
+  ASSERT_TRUE(FromGenericSelectionExpr);
+
+  const GenericSelectionExpr *ToGenericSelectionExpr =
+      selectFirst<GenericSelectionExpr>("expr", ToResults);
+  ASSERT_TRUE(ToGenericSelectionExpr);
+
+  EXPECT_EQ(FromGenericSelectionExpr->isResultDependent(),
+            ToGenericSelectionExpr->isResultDependent());
+  EXPECT_EQ(FromGenericSelectionExpr->getResultIndex(),
+            ToGenericSelectionExpr->getResultIndex());
+}
+
 TEST_P(ASTImporterOptionSpecificTestBase,
        ImportFunctionWithBackReferringParameter) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       template <typename T> struct X {};
 
       void declToImport(int y, X<int> &x) {}

clang/unittests/AST/StructuralEquivalenceTest.cpp

TEST_F(StructuralEquivalenceStmtTest, FloatingLiteralDifferentType) {
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceStmtTest, FloatingLiteralDifferentValue) {
   auto t = makeWrappedStmts("1.01", "1.0", Lang_CXX03, fallbackExprMatcher());
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
+TEST_F(StructuralEquivalenceStmtTest, GenericSelectionExprSame) {
+  auto t = makeWrappedStmts("_Generic(0u, unsigned int: 0, float: 1)",
+                            "_Generic(0u, unsigned int: 0, float: 1)", Lang_C99,
+                            genericSelectionExpr());
+  EXPECT_TRUE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceStmtTest, GenericSelectionExprSignsDiffer) {
+  auto t = makeWrappedStmts("_Generic(0u, unsigned int: 0, float: 1)",
+                            "_Generic(0, int: 0, float: 1)", Lang_C99,
+                            genericSelectionExpr());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceStmtTest, GenericSelectionExprOrderDiffers) {
+  auto t = makeWrappedStmts("_Generic(0u, unsigned int: 0, float: 1)",
+                            "_Generic(0u, float: 1, unsigned int: 0)", Lang_C99,
+                            genericSelectionExpr());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceStmtTest, GenericSelectionExprDependentResultSame) {
+  auto t = makeStmts(
+      R"(
+      template <typename T>
+      void f() {
+        T x;
+        (void)_Generic(x, int: 0, float: 1);
+      }
+      void g() { f<int>(); }
+      )",
+      R"(
+      template <typename T>
+      void f() {
+        T x;
+        (void)_Generic(x, int: 0, float: 1);
+      }
+      void g() { f<int>(); }
+      )",
+      Lang_CXX03, genericSelectionExpr());
+  EXPECT_TRUE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceStmtTest,
+       GenericSelectionExprDependentResultOrderDiffers) {
+  auto t = makeStmts(
+      R"(
+      template <typename T>
+      void f() {
+        T x;
+        (void)_Generic(x, float: 1, int: 0);
+      }
+      void g() { f<int>(); }
+      )",
+      R"(
+      template <typename T>
+      void f() {
+        T x;
+        (void)_Generic(x, int: 0, float: 1);
+      }
+      void g() { f<int>(); }
+      )",
+      Lang_CXX03, genericSelectionExpr());
+
+  EXPECT_FALSE(testStructuralMatch(t));
+}
 TEST_F(StructuralEquivalenceStmtTest, IntegerLiteral) {
   auto t = makeWrappedStmts("1", "1", Lang_CXX03, integerLiteral());
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceStmtTest, IntegerLiteralDifferentSpelling) {
   auto t = makeWrappedStmts("1", "0x1", Lang_CXX03, integerLiteral());
   // Same value but with different spelling is equivalent.

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

 
 TEST_P(ASTMatchersTest, GNUNullExpr) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(matches("int* i = __null;", gnuNullExpr()));
 }
 
+TEST_P(ASTMatchersTest, GenericSelectionExpr) {
+  EXPECT_TRUE(matches("void f() { (void)_Generic(1, int: 1, float: 2.0); }",
+                      genericSelectionExpr()));
+}
+
 TEST_P(ASTMatchersTest, AtomicExpr) {
   EXPECT_TRUE(matches("void foo() { int *ptr; __atomic_load_n(ptr, 1); }",
                       atomicExpr()));
 }
 
 TEST_P(ASTMatchersTest, Initializers_C99) {
   if (!GetParam().isC99OrLater()) {
     return;