Refactor checkConditionalParams

Author: susmonteiro

lib/ClangImporter/ClangImporter.cpp

@@ -5381,11 +5381,12 @@ static const llvm::StringMap<std::vector<int>> STLConditionalParams{
 };
 
 template <typename Kind>
-static std::optional<Kind> checkConditionalParams(
-    clang::RecordDecl *recordDecl, const std::vector<int> &STLParams,
-    std::set<StringRef> &conditionalParams,
-    std::function<std::optional<Kind>(clang::TemplateArgument &, StringRef)>
-        &checkArg) {
+static bool checkConditionalParams(
+    clang::RecordDecl *recordDecl, ClangImporter::Implementation *impl,
+    const std::vector<int> &STLParams, std::set<StringRef> &conditionalParams,
+    std::function<void(const clang::Type *)> &maybePushToStack) {
+  HeaderLoc loc{recordDecl->getLocation()};
+  bool foundErrors = false;
   auto specDecl = cast<clang::ClassTemplateSpecializationDecl>(recordDecl);
   SmallVector<std::pair<unsigned, StringRef>, 4> argumentsToCheck;
   bool hasInjectedSTLAnnotation = !STLParams.empty();
@@ -5413,9 +5414,15 @@ static std::optional<Kind> checkConditionalParams(
       } else
         nonPackArgs.push_back(arg);
       for (auto nonPackArg : nonPackArgs) {
-        auto result = checkArg(nonPackArg, argToCheck.second);
-        if (result.has_value())
-          return result.value();
+        if (nonPackArg.getKind() != clang::TemplateArgument::Type) {
+          if (impl)
+            impl->diagnose(loc, diag::type_template_parameter_expected,
+                           argToCheck.second);
+          foundErrors = true;
+        } else {
+          maybePushToStack(
+              nonPackArg.getAsType()->getUnqualifiedDesugaredType());
+        }
       }
     }
     if (hasInjectedSTLAnnotation)
@@ -5428,7 +5435,7 @@ static std::optional<Kind> checkConditionalParams(
         break;
     }
   }
-  return std::nullopt;
+  return foundErrors;
 }
 
 static std::set<StringRef>
@@ -5479,7 +5486,7 @@ ClangTypeEscapability::evaluate(Evaluator &evaluator,
   // Keep track of Decls we've seen to avoid cycles
   llvm::SmallDenseSet<const clang::Type *, 4> seen;
 
-  auto maybePushToStack = [&](const clang::Type *type) {
+  std::function maybePushToStack = [&](const clang::Type *type) {
     auto desugared = type->getUnqualifiedDesugaredType();
     if (seen.insert(desugared).second)
       stack.push_back(desugared);
@@ -5505,28 +5512,15 @@ ClangTypeEscapability::evaluate(Evaluator &evaluator,
       auto conditionalParams = getConditionalEscapableAttrParams(recordDecl);
 
       if (!STLParams.empty() || !conditionalParams.empty()) {
-        HeaderLoc loc{recordDecl->getLocation()};
-        std::function checkArgEscapability =
-            [&](clang::TemplateArgument &arg,
-                StringRef argToCheck) -> std::optional<CxxEscapability> {
-          if (arg.getKind() != clang::TemplateArgument::Type) {
-            if (desc.impl)
-              desc.impl->diagnose(loc, diag::type_template_parameter_expected,
-                                  argToCheck);
-            hasUnknown = true;
-            return std::nullopt;
-          }
-          maybePushToStack(arg.getAsType()->getUnqualifiedDesugaredType());
-          // FIXME don't return anything
-          return std::nullopt;
-        };
-
-        checkConditionalParams<CxxEscapability>(
-            recordDecl, STLParams, conditionalParams, checkArgEscapability);
+        hasUnknown &= checkConditionalParams<CxxEscapability>(
+            recordDecl, desc.impl, STLParams, conditionalParams,
+            maybePushToStack);
 
-        if (desc.impl)
+        if (desc.impl) {
+          HeaderLoc loc{recordDecl->getLocation()};
           for (auto name : conditionalParams)
             desc.impl->diagnose(loc, diag::unknown_template_parameter, name);
+        }
 
         continue;
       }
@@ -5538,11 +5532,9 @@ ClangTypeEscapability::evaluate(Evaluator &evaluator,
       if (recordDecl->getDefinition() &&
           (!cxxRecordDecl || cxxRecordDecl->isAggregate())) {
         if (cxxRecordDecl) {
-          // TODO llvm::foreach ?
           for (auto base : cxxRecordDecl->bases())
             maybePushToStack(base.getType()->getUnqualifiedDesugaredType());
         }
-
         for (auto field : recordDecl->fields())
           maybePushToStack(field->getType()->getUnqualifiedDesugaredType());
         continue;
@@ -8464,7 +8456,7 @@ CxxValueSemantics::evaluate(Evaluator &evaluator,
   // Keep track of Decls we've seen to avoid cycles
   llvm::SmallDenseSet<clang::RecordDecl *, 4> seen;
 
-  auto maybePushToStack = [&](const clang::Type *type) {
+  std::function maybePushToStack = [&](const clang::Type *type) {
     auto recordDecl = type->getAsRecordDecl();
     if (!recordDecl)
       return;
@@ -8519,11 +8511,14 @@ CxxValueSemantics::evaluate(Evaluator &evaluator,
         };
 
         checkConditionalParams<CxxValueSemanticsKind>(
-            recordDecl, STLParams, conditionalParams, checkArgValueSemantics);
+            recordDecl, importerImpl, STLParams, conditionalParams,
+            maybePushToStack);
 
-        if (importerImpl)
+        if (importerImpl) {
+          HeaderLoc loc{recordDecl->getLocation()};
           for (auto name : conditionalParams)
             importerImpl->diagnose(loc, diag::unknown_template_parameter, name);
+        }
 
         continue;
       }