[clang] Fix ICE on invalid type parameters for concepts

[mizvekov]

Summary

See PR48593.

Constraints with invalid type parameters were causing a null pointer
dereference.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

Repush, no changes.

[rsmith]

clang/lib/Sema/SemaType.cpp

1644–1661

Minor style nits: reduce scope of TemplateId variable and consistently brace the else if and only if the if is braced.

5947–5948

Given that we recover from an invalid TemplateId by creating an unconstrained AutoType, it would be more consistent to skip filling in the NestedNameSpecifierLoc here in that case too. (That way, we would populate the NestedNameSpecifierLoc if and only if we created a constrained AutoType.) I think it doesn't matter right now because no-one should look at this information for an unconstrained AutoType, but I could imagine we would switch to storing smaller TypeLoc data in the future if the type is unconstrained, and if we did, the writes to the NestedNameSpecifierLoc below would break.

[mizvekov]

clang/lib/Sema/SemaType.cpp

5947–5948

Good catch, thanks!

[mizvekov]

Addressed rsmith's concerns.
Fixed test type name to avoid picking up suggestions from other tests.

clang/lib/Sema/SemaType.cpp

 static OpenCLAccessAttr::Spelling
 getImageAccess(const ParsedAttributesView &Attrs) {
   for (const ParsedAttr &AL : Attrs)
     if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
       return static_cast<OpenCLAccessAttr::Spelling>(AL.getSemanticSpelling());
   return OpenCLAccessAttr::Keyword_read_only;
 }
 
-static QualType ConvertConstrainedAutoDeclSpecToType(Sema &S, DeclSpec &DS,
-                                                     AutoTypeKeyword AutoKW) {
-  assert(DS.isConstrainedAuto());
-  TemplateIdAnnotation *TemplateId = DS.getRepAsTemplateId();
-  TemplateArgumentListInfo TemplateArgsInfo;
-  TemplateArgsInfo.setLAngleLoc(TemplateId->LAngleLoc);
-  TemplateArgsInfo.setRAngleLoc(TemplateId->RAngleLoc);
-  ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
-                                     TemplateId->NumArgs);
-  S.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);
-  llvm::SmallVector<TemplateArgument, 8> TemplateArgs;
-  for (auto &ArgLoc : TemplateArgsInfo.arguments())
-    TemplateArgs.push_back(ArgLoc.getArgument());
-  return S.Context.getAutoType(
-      QualType(), AutoKW, false, /*IsPack=*/false,
-      cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl()),
-      TemplateArgs);
-}
-
 /// Convert the specified declspec to the appropriate type
 /// object.
 /// \param state Specifies the declarator containing the declaration specifier
 /// to be converted, along with other associated processing state.
 /// \returns The type described by the declaration specifiers.  This function
 /// never returns null.
 static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
   // FIXME: Should move the logic from DeclSpec::Finish to here for validity
Result = S.BuildUnaryTransformType(Result,
                                        DS.getTypeSpecTypeLoc());
     if (Result.isNull()) {
       Result = Context.IntTy;
       declarator.setInvalidType(true);
     }
     break;
 
   case DeclSpec::TST_auto:
+  case DeclSpec::TST_decltype_auto: {
+    auto AutoKW = DS.getTypeSpecType() == DeclSpec::TST_decltype_auto
+                      ? AutoTypeKeyword::DecltypeAuto
+                      : AutoTypeKeyword::Auto;
+
+    TemplateIdAnnotation *TemplateId = DS.getRepAsTemplateId();
+    ConceptDecl *TypeConstraintConcept = nullptr;
+    llvm::SmallVector<TemplateArgument, 8> TemplateArgs;
     if (DS.isConstrainedAuto()) {
-      Result = ConvertConstrainedAutoDeclSpecToType(S, DS,
-                                                    AutoTypeKeyword::Auto);
-      break;
+      if (TemplateId) {
+        TypeConstraintConcept =
+            cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl());
+        TemplateArgumentListInfo TemplateArgsInfo;
+        TemplateArgsInfo.setLAngleLoc(TemplateId->LAngleLoc);
+        TemplateArgsInfo.setRAngleLoc(TemplateId->RAngleLoc);
+        ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
+                                           TemplateId->NumArgs);
+        S.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);
+        for (auto &ArgLoc : TemplateArgsInfo.arguments())
+          TemplateArgs.push_back(ArgLoc.getArgument());
+      } else
+        declarator.setInvalidType(true);
     }
-    Result = Context.getAutoType(QualType(), AutoTypeKeyword::Auto, false);
+    Result = S.Context.getAutoType(QualType(), AutoKW,
+                                   /*IsDependent*/ false, /*IsPack=*/false,
+                                   TypeConstraintConcept, TemplateArgs);
     break;
+  }
 
   case DeclSpec::TST_auto_type:
     Result = Context.getAutoType(QualType(), AutoTypeKeyword::GNUAutoType, false);
     break;
 
-  case DeclSpec::TST_decltype_auto:
-    if (DS.isConstrainedAuto()) {
-      Result =
-          ConvertConstrainedAutoDeclSpecToType(S, DS,
-                                               AutoTypeKeyword::DecltypeAuto);
-      break;
-    }
-    Result = Context.getAutoType(QualType(), AutoTypeKeyword::DecltypeAuto,
-                                 /*IsDependent*/ false);
-    break;
-
   case DeclSpec::TST_unknown_anytype:
     Result = Context.UnknownAnyTy;
     break;
 
   case DeclSpec::TST_atomic:
     Result = S.GetTypeFromParser(DS.getRepAsType());
     assert(!Result.isNull() && "Didn't get a type for _Atomic?");
     Result = S.BuildAtomicType(Result, DS.getTypeSpecTypeLoc());
void VisitDependentTemplateSpecializationTypeLoc(
           TInfo->getTypeLoc().castAs<DependentTemplateSpecializationTypeLoc>());
     }
     void VisitAutoTypeLoc(AutoTypeLoc TL) {
       assert(DS.getTypeSpecType() == TST_auto ||
              DS.getTypeSpecType() == TST_decltype_auto ||
              DS.getTypeSpecType() == TST_auto_type ||
              DS.getTypeSpecType() == TST_unspecified);
       TL.setNameLoc(DS.getTypeSpecTypeLoc());
       if (!DS.isConstrainedAuto())
         return;
-      TemplateIdAnnotation *TemplateId = DS.getRepAsTemplateId();
       if (DS.getTypeSpecScope().isNotEmpty())
         TL.setNestedNameSpecifierLoc(
             DS.getTypeSpecScope().getWithLocInContext(Context));
       else
         TL.setNestedNameSpecifierLoc(NestedNameSpecifierLoc());
+      TL.setFoundDecl(nullptr);
+      TemplateIdAnnotation *TemplateId = DS.getRepAsTemplateId();
+      if (!TemplateId)
+        return;
       TL.setTemplateKWLoc(TemplateId->TemplateKWLoc);
       TL.setConceptNameLoc(TemplateId->TemplateNameLoc);
-      TL.setFoundDecl(nullptr);
       TL.setLAngleLoc(TemplateId->LAngleLoc);
       TL.setRAngleLoc(TemplateId->RAngleLoc);
       if (TemplateId->NumArgs == 0)
         return;
       TemplateArgumentListInfo TemplateArgsInfo;
       ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
                                          TemplateId->NumArgs);
       SemaRef.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);

clang/test/CXX/dcl/dcl.spec/dcl.type/dcl.spec.auto/p6.cpp

namespace PR48384 {
   static_assert(is_same_v<decltype(f), int&>);
 
   True decltype(auto) g = (a);
   static_assert(is_same_v<decltype(g), int&>);
 
   True decltype(auto) h = (b);
   static_assert(is_same_v<decltype(h), int&>);
 }
+
+namespace PR48593 {
+  template <class T, class U> concept a = true; // expected-note{{template parameter is declared here}}
+  a<b> auto c = 0; // expected-error{{template argument for template type parameter must be a type}}
+
+  template<class> concept d = true;
+  d<,> auto e = 0; // expected-error{{expected expression}}
+}