[experimental] Support templates

Support returned dependent types and class tempate instantiations.

Author: a-nogikh

clang/include/clang/Sema/Sema.h

@@ -5105,6 +5105,11 @@ class Sema final : public SemaBase {
   /// Essentially, this just moves them to the current pool.
   void redelayDiagnostics(sema::DelayedDiagnosticPool &pool);
 
+  /// Check that the type is a plain record with one field being a pointer
+  /// type and the other field being an integer. This matches the common
+  /// implementation of std::span or sized_allocation_t in P0901R11.
+  bool CheckSpanLikeType(const AttributeCommonInfo &CI, const QualType &Ty);
+
   /// Check if IdxExpr is a valid parameter index for a function or
   /// instance method D.  May output an error.
   ///

clang/lib/Sema/SemaDeclAttr.cpp

@@ -1839,19 +1839,24 @@ static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
                  RestrictAttr(S.Context, AL, DeallocE, DeallocPtrIdx));
 }
 
-static bool checkSpanLikeType(Sema &S, const ParsedAttr &AL,
-                              const QualType &Ty) {
-  // Check that the type is a plain record with one field being a pointer
-  // type and the other field being an integer. This matches the common
-  // implementation of std::span or sized_allocation_t in P0901R11.
+bool Sema::CheckSpanLikeType(const AttributeCommonInfo &CI,
+                             const QualType &Ty) {
   // Note that there may also be numerous cases of pointer + integer /
   // pointer + pointer / integer + pointer structures not actually exhibiting
   // a span-like semantics, so sometimes these heuristics expectedly
   // lead to false positive results.
-  auto emitWarning = [&S, &AL](unsigned NoteDiagID) {
-    S.Diag(AL.getLoc(), diag::warn_attribute_return_span_only) << AL;
-    return S.Diag(AL.getLoc(), NoteDiagID);
+  auto emitWarning = [this, &CI](unsigned NoteDiagID) {
+    Diag(CI.getLoc(), diag::warn_attribute_return_span_only) << CI;
+    return Diag(CI.getLoc(), NoteDiagID);
   };
+  if (!Ty->isDependentType()) {
+    // If the type is a class template specialization, it may not be
+    // instantiated at this stage. We must force it to be complete to examine
+    // its fields.
+    // The returned value is discarded since the code below emits a warning
+    // if the type keeps being incomplete.
+    (void)isCompleteType(CI.getLoc(), Ty);
+  }
   if (Ty->isIncompleteType())
     return emitWarning(diag::note_returned_incomplete_type);
   const RecordDecl *RD = Ty->getAsRecordDecl();
@@ -1867,13 +1872,13 @@ static bool checkSpanLikeType(Sema &S, const ParsedAttr &AL,
     // It must not point to functions.
     return T->isPointerType() && !T->isFunctionPointerType();
   };
-  auto checkIntegerType = [&S, emitWarning](const QualType &T,
-                                            const int FieldNo) -> bool {
+  auto checkIntegerType = [this, emitWarning](const QualType &T,
+                                              const int FieldNo) -> bool {
     const auto *BT = dyn_cast<BuiltinType>(T.getCanonicalType());
     if (!BT || !BT->isInteger())
       return emitWarning(diag::note_returned_not_integer_field) << FieldNo;
-    const auto IntSize = S.Context.getTypeSize(S.Context.IntTy);
-    if (S.Context.getTypeSize(BT) < IntSize)
+    const auto IntSize = Context.getTypeSize(Context.IntTy);
+    if (Context.getTypeSize(BT) < IntSize)
       return emitWarning(diag::note_returned_not_wide_enough_field)
              << FieldNo << IntSize;
     return false;
@@ -1894,7 +1899,9 @@ static bool checkSpanLikeType(Sema &S, const ParsedAttr &AL,
 
 static void handleMallocSpanAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   QualType ResultType = getFunctionOrMethodResultType(D);
-  if (!checkSpanLikeType(S, AL, ResultType)) {
+  if (ResultType->isDependentType() || !S.CheckSpanLikeType(AL, ResultType)) {
+    // If it's a dependent type, the attribute will be re-checked upon
+    // instantiation.
     D->addAttr(::new (S.Context) MallocSpanAttr(S.Context, AL));
   }
 }

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -796,6 +796,20 @@ static void instantiateDependentHLSLParamModifierAttr(
       "out or inout parameter type must be a reference and restrict qualified");
 }
 
+static void instantiateDependentMallocSpanAttr(Sema &S,
+                                               const MallocSpanAttr *Attr,
+                                               Decl *New) {
+  QualType RT = getFunctionOrMethodResultType(New);
+  if (RT->isDependentType()) {
+    // The type is still dependent.
+    // Clone the attribute, it will be checked later.
+    New->addAttr(Attr->clone(S.getASTContext()));
+  } else if (!S.CheckSpanLikeType(*Attr, RT)) {
+    // The conditions have been successfully validated.
+    New->addAttr(Attr->clone(S.getASTContext()));
+  }
+}
+
 void Sema::InstantiateAttrsForDecl(
     const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
     Decl *New, LateInstantiatedAttrVec *LateAttrs,
@@ -1007,6 +1021,11 @@ void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
       continue;
     }
 
+    if (auto *A = dyn_cast<MallocSpanAttr>(TmplAttr)) {
+      instantiateDependentMallocSpanAttr(*this, A, New);
+      continue;
+    }
+
     assert(!TmplAttr->isPackExpansion());
     if (TmplAttr->isLateParsed() && LateAttrs) {
       // Late parsed attributes must be instantiated and attached after the

clang/test/SemaCXX/attr-malloc_span.cpp

@@ -29,3 +29,46 @@ MemberFuncSpan returns_member_func_span(void) __attribute((malloc_span)) {
   return MemberFuncSpan{};
 }
 
+template<typename FirstType, typename SecondType>
+struct Pair {
+  FirstType first;
+  SecondType second;
+};
+
+Pair<int*, int> returns_templated_span1(void) __attribute((malloc_span)) { // no-warning
+  return Pair<int*, int>{};
+}
+
+Pair<int*, int*> returns_templated_span2(void) __attribute((malloc_span)) { // no-warning
+  return Pair<int*, int*>{};
+}
+
+// expected-warning@+2 {{attribute only applies to functions that return span-like structures}}
+// expected-note@+1 {{returned struct/class fields are not a supported combination for a span-like type}}
+Pair<int, int> returns_templated_span3(void) __attribute((malloc_span)) {
+  return Pair<int, int>{};
+}
+
+// Verify that semantic checks are done on dependent types.
+
+struct GoodSpan {
+  void *ptr;
+  int n;
+};
+
+struct BadSpan {
+  int n;
+};
+
+template <typename T>
+// expected-warning@+2 {{'malloc_span' attribute only applies to functions that return span-like structures}}
+// expected-note@+1 {{returned struct/class has 1 fields, expected 2}}
+T produce_span() __attribute((malloc_span)) {
+  return T{};
+}
+
+void TestGoodBadSpan() {
+  produce_span<GoodSpan>(); // no-warnings
+  // expected-note@+1 {{in instantiation of function template specialization 'produce_span<BadSpan>' requested here}}
+  produce_span<BadSpan>();
+}