[lldb] Remove checks behind LLDB_CONFIGURATION_DEBUG from TypeSystemClang

[teemperor]

Summary

This function is (supposed) to be a list of asserts that just do a generic sanity check
on declarations we return. Right now this function is hidden behind the
LLDB_CONFIGURATION_DEBUG macro which means it will *only* be run in
debug builds (but not Release+assert builds and so on).

As we have not a single CI running in Debug build, failures in VerifyDecl are hidden
from us until someone by accident executes the tests in Debug mode on their own machine.

This patch removes the ifdef's for LLDB_CONFIGURATION_DEBUG and puts
the getAccess() call in VerifyDecl behind a #ifndef NDEBUG to make sure
that this function is just an empty function with internal linkage when NDEBUG
is defined (so compilers should just optimize away the calls to it).

[aprantl]

Great! You might want to do a git grep for LLDB_CONFIGURATION_DEBUG to find other instances, too.

[shafik]

Nice fix!

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

 using namespace lldb;
 using namespace lldb_private;
 using namespace clang;
 using llvm::StringSwitch;
 
 LLDB_PLUGIN_DEFINE(TypeSystemClang)
 
 namespace {
-#ifdef LLDB_CONFIGURATION_DEBUG
 static void VerifyDecl(clang::Decl *decl) {
   assert(decl && "VerifyDecl called with nullptr?");
+#ifndef NDEBUG
+  // We don't care about the actual access value here but only want to trigger
+  // that Clang calls its internal Decl::AccessDeclContextSanity check.
   decl->getAccess();
-}
 #endif
+}
 
 static inline bool
 TypeSystemClangSupportsLanguage(lldb::LanguageType language) {
   return language == eLanguageTypeUnknown || // Clang is the default type system
          lldb_private::Language::LanguageIsC(language) ||
          lldb_private::Language::LanguageIsCPlusPlus(language) ||
          lldb_private::Language::LanguageIsObjC(language) ||
          lldb_private::Language::LanguageIsPascal(language) ||
if (access_type != eAccessNone)
       class_template_decl->setAccess(
           ConvertAccessTypeToAccessSpecifier(access_type));
 
     // if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx))
     //    CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl));
 
     decl_ctx->addDecl(class_template_decl);
 
-#ifdef LLDB_CONFIGURATION_DEBUG
     VerifyDecl(class_template_decl);
-#endif
   }
 
   return class_template_decl;
 }
 
 TemplateTemplateParmDecl *
 TypeSystemClang::CreateTemplateTemplateParmDecl(const char *template_name) {
   ASTContext &ast = getASTContext();
if (decl_ctx == translation_unit_decl) {
         assert(namespace_decl ==
                parent_namespace_decl->getAnonymousNamespace());
       } else {
         assert(false && "GetUniqueNamespaceDeclaration called with no name and "
                         "no namespace as decl_ctx");
       }
     }
   }
-#ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(namespace_decl);
-#endif
   return namespace_decl;
 }
 
 clang::BlockDecl *
 TypeSystemClang::CreateBlockDeclaration(clang::DeclContext *ctx) {
   if (ctx != nullptr) {
     clang::BlockDecl *decl =
         clang::BlockDecl::Create(getASTContext(), ctx, clang::SourceLocation());
FunctionDecl *TypeSystemClang::CreateFunctionDeclaration(
   func_decl = FunctionDecl::Create(
       ast, decl_ctx, SourceLocation(), SourceLocation(), declarationName,
       ClangUtil::GetQualType(function_clang_type), nullptr,
       (clang::StorageClass)storage, is_inline, hasWrittenPrototype,
       isConstexprSpecified ? CSK_constexpr : CSK_unspecified);
   if (func_decl)
     decl_ctx->addDecl(func_decl);
 
-#ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(func_decl);
-#endif
 
   return func_decl;
 }
 
 CompilerType
 TypeSystemClang::CreateFunctionType(const CompilerType &result_type,
                                     const CompilerType *args, unsigned num_args,
                                     bool is_variadic, unsigned type_quals,
if (record_decl) {
     }
 
     if (field) {
       field->setAccess(
           TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access));
 
       record_decl->addDecl(field);
 
-#ifdef LLDB_CONFIGURATION_DEBUG
       VerifyDecl(field);
-#endif
     }
   } else {
     clang::ObjCInterfaceDecl *class_interface_decl =
         ast->GetAsObjCInterfaceDecl(type);
 
     if (class_interface_decl) {
       const bool is_synthesized = false;
 
       field_clang_type.GetCompleteType();
 
       field = clang::ObjCIvarDecl::Create(
           clang_ast, class_interface_decl, clang::SourceLocation(),
           clang::SourceLocation(),
           ident,                                    // Identifier
           ClangUtil::GetQualType(field_clang_type), // Field type
           nullptr,                                  // TypeSourceInfo *
           ConvertAccessTypeToObjCIvarAccessControl(access), bit_width,
           is_synthesized);
 
       if (field) {
         class_interface_decl->addDecl(field);
 
-#ifdef LLDB_CONFIGURATION_DEBUG
         VerifyDecl(field);
-#endif
       }
     }
   }
   return field;
 }
 
 void TypeSystemClang::BuildIndirectFields(const CompilerType &type) {
   if (!type)
var_decl = clang::VarDecl::Create(
       clang::SC_Static);                // StorageClass
   if (!var_decl)
     return nullptr;
 
   var_decl->setAccess(
       TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access));
   record_decl->addDecl(var_decl);
 
-#ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(var_decl);
-#endif
 
   return var_decl;
 }
 
 clang::CXXMethodDecl *TypeSystemClang::AddMethodToCXXRecordType(
     lldb::opaque_compiler_type_t type, llvm::StringRef name,
     const char *mangled_name, const CompilerType &method_clang_type,
     lldb::AccessType access, bool is_virtual, bool is_static, bool is_inline,
if (cxx_ctor_decl && ((cxx_ctor_decl->isDefaultConstructor() &&
                 cxx_record_decl->hasTrivialCopyAssignment()) ||
                (cxx_method_decl->isMoveAssignmentOperator() &&
                 cxx_record_decl->hasTrivialMoveAssignment())) {
       cxx_method_decl->setDefaulted();
       cxx_method_decl->setTrivial(true);
     }
   }
 
-#ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(cxx_method_decl);
-#endif
 
   return cxx_method_decl;
 }
 
 void TypeSystemClang::AddMethodOverridesForCXXRecordType(
     lldb::opaque_compiler_type_t type) {
   if (auto *record = GetAsCXXRecordDecl(type))
     for (auto *method : record->methods())
if (is_objc_direct_call) {
     // parses the method. We don't have a parsing Sema when we build our own
     // AST here so we manually need to create these implicit parameters to
     // make the direct call code generation happy.
     objc_method_decl->createImplicitParams(ast, class_interface_decl);
   }
 
   class_interface_decl->addDecl(objc_method_decl);
 
-#ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(objc_method_decl);
-#endif
 
   return objc_method_decl;
 }
 
 bool TypeSystemClang::SetHasExternalStorage(lldb::opaque_compiler_type_t type,
                                             bool has_extern) {
   if (!type)
     return false;
clang::EnumConstantDecl *enumerator_decl = clang::EnumConstantDecl::Create(
       name ? &getASTContext().Idents.get(name) : nullptr, // Identifier
       clang::QualType(enutype, 0), nullptr, value);
 
   if (!enumerator_decl)
     return nullptr;
 
   enutype->getDecl()->addDecl(enumerator_decl);
 
-#ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(enumerator_decl);
-#endif
-
   return enumerator_decl;
 }
 
 clang::EnumConstantDecl *TypeSystemClang::AddEnumerationValueToEnumerationType(
     const CompilerType &enum_type, const Declaration &decl, const char *name,
     int64_t enum_value, uint32_t enum_value_bit_size) {
   CompilerType underlying_type = GetEnumerationIntegerType(enum_type);
   bool is_signed = false;