[BoundsSafety] Delay processing of bounds attrs in templates (#9929)

* [BoundsSafety] Delay processing of bounds attrs in templates

Dynamic bounds attributes do not handle value dependent arguments. To
enable wider interop with C++ code bases we delay the processing of
these attributes inside templated contexts. Instead we apply the new
type while instantiating the function.

One issue with this approach is that instantiation happens after parsing
is finished, and the Scope information we use to prevent attributes from
referring to arguments from outer scopes is only available during
parsing. These diagnostics were emitted at the end of the type
processing. In templated contexts we instead perform that analysis
during parsing, and delay the rest of the processing. To avoid churn in
unrelated tests the rest of the attributes keep their processing as is,
until we've investigated what impact hoisting it would have on the user
experience.

Author: hnrklssn

clang/include/clang/Sema/Sema.h

@@ -15509,7 +15509,8 @@ class Sema final : public SemaBase {
                                     AttributeCommonInfo::Kind Kind,
                                     Expr *AttrArg, SourceLocation Loc,
                                     SourceRange Range, StringRef DiagName,
-                                    bool OriginatesInAPINotes = false);
+                                    bool OriginatesInAPINotes = false,
+                                    bool InInstantiatedTemplate = false);
 
   /// Perform Bounds Safety Semantic checks for assigning to a `__counted_by` or
   /// `__counted_by_or_null` pointer type \param LHSTy.

clang/lib/Sema/BoundsSafetySuggestions.cpp

@@ -1594,6 +1594,10 @@ void UnsafeOperationVisitor::
       Current = PE->getSubExpr();
       continue;
     }
+    if (const auto *BCE = dyn_cast<BoundsCheckExpr>(Current)) {
+      Current = BCE->getGuardedExpr();
+      continue;
+    }
     if (const auto *CE = dyn_cast<CastExpr>(Current)) {
       if (CE->getCastKind() == clang::CK_BoundsSafetyPointerCast) {
         // Found a cast we might want to warn about.

clang/lib/Sema/DynamicCountPointerAssignmentAnalysis.cpp

@@ -3484,6 +3484,9 @@ namespace clang {
 
 void DynamicCountPointerAssignmentAnalysis::run() {
   AnalysisDeclContext AC(/* AnalysisDeclContextManager */ nullptr, dcl);
+  if (dcl->isTemplated()) // delay processing until template has been
+                          // instantiated
+    return;
 
   CFG *cfg = AC.getCFG();
   if (!cfg)

clang/lib/Sema/SemaDecl.cpp

@@ -17302,6 +17302,11 @@ Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
     // the declaration context below. Otherwise, we're unable to transform
     // 'this' expressions when transforming immediate context functions.
 
+  /*TO_UPSTREAM(BoundsSafety) ON*/
+  if (LangOpts.BoundsSafety)
+    DynamicCountPointerAssignmentAnalysis(*this, dcl).run();
+  /*TO_UPSTREAM(BoundsSafety) OFF*/
+
   if (!IsInstantiation)
     PopDeclContext();
 
@@ -17325,11 +17330,6 @@ Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
   if (FD && !FD->isDeleted())
     checkTypeSupport(FD->getType(), FD->getLocation(), FD);
 
-  /*TO_UPSTREAM(BoundsSafety) ON*/
-  if (LangOpts.BoundsSafety)
-    DynamicCountPointerAssignmentAnalysis(*this, dcl).run();
-  /*TO_UPSTREAM(BoundsSafety) OFF*/
-
   return dcl;
 }