[clang] Use std::size instead of llvm::array_lengthof

[jloser]

Summary

LLVM contains a helpful function for getting the size of a C-style
array: llvm::array_lengthof. This is useful prior to C++17, but not as
helpful for C++17 or later: std::size already has support for C-style
arrays.

Change call sites to use std::size instead. Leave the few call sites that
use a locally defined array_lengthof that are meant to test previous bugs
with NTTPs in clang analyzer and SemaTemplate.

clang/include/clang/AST/OpenMPClause.h

explicit OMPMapClause(ArrayRef<OpenMPMapModifierKind> MapModifiers,
                         DeclarationNameInfo MapperIdInfo,
                         OpenMPMapClauseKind MapType, bool MapTypeIsImplicit,
                         SourceLocation MapLoc, const OMPVarListLocTy &Locs,
                         const OMPMappableExprListSizeTy &Sizes)
       : OMPMappableExprListClause(llvm::omp::OMPC_map, Locs, Sizes,
                                   /*SupportsMapper=*/true, &MapperQualifierLoc,
                                   &MapperIdInfo),
         MapType(MapType), MapTypeIsImplicit(MapTypeIsImplicit), MapLoc(MapLoc) {
-    assert(llvm::array_lengthof(MapTypeModifiers) == MapModifiers.size() &&
+    assert(std::size(MapTypeModifiers) == MapModifiers.size() &&
            "Unexpected number of map type modifiers.");
     llvm::copy(MapModifiers, std::begin(MapTypeModifiers));
 
-    assert(llvm::array_lengthof(MapTypeModifiersLoc) ==
-               MapModifiersLoc.size() &&
+    assert(std::size(MapTypeModifiersLoc) == MapModifiersLoc.size() &&
            "Unexpected number of map type modifier locations.");
     llvm::copy(MapModifiersLoc, std::begin(MapTypeModifiersLoc));
   }
 
   /// Build an empty clause.
   ///
   /// \param Sizes All required sizes to build a mappable clause. It includes 1)
   /// NumVars: number of expressions listed in this clause; 2)
explicit OMPToClause(ArrayRef<OpenMPMotionModifierKind> TheMotionModifiers,
                        ArrayRef<SourceLocation> TheMotionModifiersLoc,
                        NestedNameSpecifierLoc MapperQualifierLoc,
                        DeclarationNameInfo MapperIdInfo,
                        const OMPVarListLocTy &Locs,
                        const OMPMappableExprListSizeTy &Sizes)
       : OMPMappableExprListClause(llvm::omp::OMPC_to, Locs, Sizes,
                                   /*SupportsMapper=*/true, &MapperQualifierLoc,
                                   &MapperIdInfo) {
-    assert(llvm::array_lengthof(MotionModifiers) == TheMotionModifiers.size() &&
+    assert(std::size(MotionModifiers) == TheMotionModifiers.size() &&
            "Unexpected number of motion modifiers.");
     llvm::copy(TheMotionModifiers, std::begin(MotionModifiers));
 
-    assert(llvm::array_lengthof(MotionModifiersLoc) ==
-               TheMotionModifiersLoc.size() &&
+    assert(std::size(MotionModifiersLoc) == TheMotionModifiersLoc.size() &&
            "Unexpected number of motion modifier locations.");
     llvm::copy(TheMotionModifiersLoc, std::begin(MotionModifiersLoc));
   }
 
   /// Build an empty clause.
   ///
   /// \param Sizes All required sizes to build a mappable clause. It includes 1)
   /// NumVars: number of expressions listed in this clause; 2)
explicit OMPFromClause(ArrayRef<OpenMPMotionModifierKind> TheMotionModifiers,
                          ArrayRef<SourceLocation> TheMotionModifiersLoc,
                          NestedNameSpecifierLoc MapperQualifierLoc,
                          DeclarationNameInfo MapperIdInfo,
                          const OMPVarListLocTy &Locs,
                          const OMPMappableExprListSizeTy &Sizes)
       : OMPMappableExprListClause(llvm::omp::OMPC_from, Locs, Sizes,
                                   /*SupportsMapper=*/true, &MapperQualifierLoc,
                                   &MapperIdInfo) {
-    assert(llvm::array_lengthof(MotionModifiers) == TheMotionModifiers.size() &&
+    assert(std::size(MotionModifiers) == TheMotionModifiers.size() &&
            "Unexpected number of motion modifiers.");
     llvm::copy(TheMotionModifiers, std::begin(MotionModifiers));
 
-    assert(llvm::array_lengthof(MotionModifiersLoc) ==
-               TheMotionModifiersLoc.size() &&
+    assert(std::size(MotionModifiersLoc) == TheMotionModifiersLoc.size() &&
            "Unexpected number of motion modifier locations.");
     llvm::copy(TheMotionModifiersLoc, std::begin(MotionModifiersLoc));
   }
 
   /// Build an empty clause.
   ///
   /// \param Sizes All required sizes to build a mappable clause. It includes 1)
   /// NumVars: number of expressions listed in this clause; 2)

clang/lib/AST/AttrDocTable.cpp

 #include "AttrDocTable.inc"
 
 static const llvm::StringRef AttrDoc[] = {
 #define ATTR(NAME) AttrDoc_##NAME,
 #include "clang/Basic/AttrList.inc"
 };
 
 llvm::StringRef clang::Attr::getDocumentation(clang::attr::Kind K) {
-  if(K < llvm::array_lengthof(AttrDoc))
+  if (K < std::size(AttrDoc))
     return AttrDoc[K];
   return "";
 }

clang/lib/AST/CommentCommandTraits.cpp

 #include <cassert>
 
 namespace clang {
 namespace comments {
 
 #include "clang/AST/CommentCommandInfo.inc"
 
 CommandTraits::CommandTraits(llvm::BumpPtrAllocator &Allocator,
-                             const CommentOptions &CommentOptions) :
-    NextID(llvm::array_lengthof(Commands)), Allocator(Allocator) {
+                             const CommentOptions &CommentOptions)
+    : NextID(std::size(Commands)), Allocator(Allocator) {
   registerCommentOptions(CommentOptions);
 }
 
 void CommandTraits::registerCommentOptions(
     const CommentOptions &CommentOptions) {
   for (CommentOptions::BlockCommandNamesTy::const_iterator
            I = CommentOptions.BlockCommandNames.begin(),
            E = CommentOptions.BlockCommandNames.end();

 const CommandInfo *CommandTraits::registerBlockCommand(StringRef CommandName) {
   CommandInfo *Info = createCommandInfoWithName(CommandName);
   Info->IsBlockCommand = true;
   return Info;
 }
 
 const CommandInfo *CommandTraits::getBuiltinCommandInfo(
                                                   unsigned CommandID) {
-  if (CommandID < llvm::array_lengthof(Commands))
+  if (CommandID < std::size(Commands))
     return &Commands[CommandID];
   return nullptr;
 }
 
 const CommandInfo *CommandTraits::getRegisteredCommandInfo(
                                                   StringRef Name) const {
   for (unsigned i = 0, e = RegisteredCommands.size(); i != e; ++i) {
     if (RegisteredCommands[i]->Name == Name)
       return RegisteredCommands[i];
   }
   return nullptr;
 }
 
 const CommandInfo *CommandTraits::getRegisteredCommandInfo(
                                                   unsigned CommandID) const {
-  return RegisteredCommands[CommandID - llvm::array_lengthof(Commands)];
+  return RegisteredCommands[CommandID - std::size(Commands)];
 }
 
 } // end namespace comments
 } // end namespace clang
 

clang/lib/Basic/DiagnosticIDs.cpp

 #include "clang/Basic/DiagnosticAnalysisKinds.inc"
 #include "clang/Basic/DiagnosticRefactoringKinds.inc"
 // clang-format on
 #undef DIAG
 };
 
 } // namespace
 
-static const unsigned StaticDiagInfoSize = llvm::array_lengthof(StaticDiagInfo);
+static const unsigned StaticDiagInfoSize = std::size(StaticDiagInfo);
 
 /// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID,
 /// or null if the ID is invalid.
 static const StaticDiagInfoRec *GetDiagInfo(unsigned DiagID) {
   // Out of bounds diag. Can't be in the table.
   using namespace diag;
   if (DiagID >= DIAG_UPPER_LIMIT || DiagID <= DIAG_START_COMMON)
     return nullptr;

 #define CATEGORY(X, ENUM) { X, STR_SIZE(X, uint8_t) },
 #include "clang/Basic/DiagnosticGroups.inc"
 #undef GET_CATEGORY_TABLE
   { nullptr, 0 }
 };
 
 /// getNumberOfCategories - Return the number of categories
 unsigned DiagnosticIDs::getNumberOfCategories() {
-  return llvm::array_lengthof(CategoryNameTable) - 1;
+  return std::size(CategoryNameTable) - 1;
 }
 
 /// getCategoryNameFromID - Given a category ID, return the name of the
 /// category, an empty string if CategoryID is zero, or null if CategoryID is
 /// invalid.
 StringRef DiagnosticIDs::getCategoryNameFromID(unsigned CategoryID) {
   if (CategoryID >= getNumberOfCategories())
    return StringRef();

clang/lib/Basic/Targets/NVPTX.h

public:
   /// \returns If a target requires an address within a target specific address
   /// space \p AddressSpace to be converted in order to be used, then return the
   /// corresponding target specific DWARF address space.
   ///
   /// \returns Otherwise return None and no conversion will be emitted in the
   /// DWARF.
   Optional<unsigned>
   getDWARFAddressSpace(unsigned AddressSpace) const override {
-    if (AddressSpace >= llvm::array_lengthof(NVPTXDWARFAddrSpaceMap) ||
+    if (AddressSpace >= std::size(NVPTXDWARFAddrSpaceMap) ||
         NVPTXDWARFAddrSpaceMap[AddressSpace] < 0)
       return llvm::None;
     return NVPTXDWARFAddrSpaceMap[AddressSpace];
   }
 
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
     // CUDA compilations support all of the host's calling conventions.
     //

clang/lib/CodeGen/CGExpr.cpp

 
 void CodeGenFunction::EmitCheck(
     ArrayRef<std::pair<llvm::Value *, SanitizerMask>> Checked,
     SanitizerHandler CheckHandler, ArrayRef<llvm::Constant *> StaticArgs,
     ArrayRef<llvm::Value *> DynamicArgs) {
   assert(IsSanitizerScope);
   assert(Checked.size() > 0);
   assert(CheckHandler >= 0 &&
-         size_t(CheckHandler) < llvm::array_lengthof(SanitizerHandlers));
+         size_t(CheckHandler) < std::size(SanitizerHandlers));
   const StringRef CheckName = SanitizerHandlers[CheckHandler].Name;
 
   llvm::Value *FatalCond = nullptr;
   llvm::Value *RecoverableCond = nullptr;
   llvm::Value *TrapCond = nullptr;
   for (int i = 0, n = Checked.size(); i < n; ++i) {
     llvm::Value *Check = Checked[i].first;
     // -fsanitize-trap= overrides -fsanitize-recover=.

clang/lib/CodeGen/CGObjC.cpp

void CodeGenFunction::EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S){
 
   // Fetch the countByEnumeratingWithState:objects:count: selector.
   IdentifierInfo *II[] = {
     &CGM.getContext().Idents.get("countByEnumeratingWithState"),
     &CGM.getContext().Idents.get("objects"),
     &CGM.getContext().Idents.get("count")
   };
   Selector FastEnumSel =
-    CGM.getContext().Selectors.getSelector(llvm::array_lengthof(II), &II[0]);
+      CGM.getContext().Selectors.getSelector(std::size(II), &II[0]);
 
   QualType ItemsTy =
     getContext().getConstantArrayType(getContext().getObjCIdType(),
                                       llvm::APInt(32, NumItems), nullptr,
                                       ArrayType::Normal, 0);
   Address ItemsPtr = CreateMemTemp(ItemsTy, "items.ptr");
 
   // Emit the collection pointer.  In ARC, we do a retain.

clang/lib/Driver/ToolChains/Darwin.cpp

getDeploymentTargetFromEnvironmentVariables(const Driver &TheDriver,
   std::string Targets[Darwin::LastDarwinPlatform + 1];
   const char *EnvVars[] = {
       "MACOSX_DEPLOYMENT_TARGET",
       "IPHONEOS_DEPLOYMENT_TARGET",
       "TVOS_DEPLOYMENT_TARGET",
       "WATCHOS_DEPLOYMENT_TARGET",
       "DRIVERKIT_DEPLOYMENT_TARGET",
   };
-  static_assert(llvm::array_lengthof(EnvVars) == Darwin::LastDarwinPlatform + 1,
+  static_assert(std::size(EnvVars) == Darwin::LastDarwinPlatform + 1,
                 "Missing platform");
   for (const auto &I : llvm::enumerate(llvm::makeArrayRef(EnvVars))) {
     if (char *Env = ::getenv(I.value()))
       Targets[I.index()] = Env;
   }
 
   // Allow conflicts among OSX and iOS for historical reasons, but choose the
   // default platform.
   if (!Targets[Darwin::MacOS].empty() &&
       (!Targets[Darwin::IPhoneOS].empty() ||
        !Targets[Darwin::WatchOS].empty() || !Targets[Darwin::TvOS].empty())) {
     if (Triple.getArch() == llvm::Triple::arm ||
         Triple.getArch() == llvm::Triple::aarch64 ||
         Triple.getArch() == llvm::Triple::thumb)
       Targets[Darwin::MacOS] = "";
     else
       Targets[Darwin::IPhoneOS] = Targets[Darwin::WatchOS] =
           Targets[Darwin::TvOS] = "";
   } else {
     // Don't allow conflicts in any other platform.
-    unsigned FirstTarget = llvm::array_lengthof(Targets);
-    for (unsigned I = 0; I != llvm::array_lengthof(Targets); ++I) {
+    unsigned FirstTarget = std::size(Targets);
+    for (unsigned I = 0; I != std::size(Targets); ++I) {
       if (Targets[I].empty())
         continue;
-      if (FirstTarget == llvm::array_lengthof(Targets))
+      if (FirstTarget == std::size(Targets))
         FirstTarget = I;
       else
         TheDriver.Diag(diag::err_drv_conflicting_deployment_targets)
             << Targets[FirstTarget] << Targets[I];
     }
   }
 
   for (const auto &Target : llvm::enumerate(llvm::makeArrayRef(Targets))) {

clang/lib/Driver/Types.cpp

 };
 
 static constexpr TypeInfo TypeInfos[] = {
 #define TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, ...) \
   { NAME, TEMP_SUFFIX, TY_##PP_TYPE, { __VA_ARGS__ }, },
 #include "clang/Driver/Types.def"
 #undef TYPE
 };
-static const unsigned numTypes = llvm::array_lengthof(TypeInfos);
+static const unsigned numTypes = std::size(TypeInfos);
 
 static const TypeInfo &getInfo(unsigned id) {
   assert(id > 0 && id - 1 < numTypes && "Invalid Type ID.");
   return TypeInfos[id - 1];
 }
 
 const char *types::getTypeName(ID Id) {
   return getInfo(Id).Name;

clang/lib/Frontend/PrintPreprocessedOutput.cpp

if (DropComments && Tok.is(tok::comment)) {
       // will be reproduced in the preprocessed output.
       PP.Lex(Tok);
       continue;
     } else if (IdentifierInfo *II = Tok.getIdentifierInfo()) {
       OS << II->getName();
     } else if (Tok.isLiteral() && !Tok.needsCleaning() &&
                Tok.getLiteralData()) {
       OS.write(Tok.getLiteralData(), Tok.getLength());
-    } else if (Tok.getLength() < llvm::array_lengthof(Buffer)) {
+    } else if (Tok.getLength() < std::size(Buffer)) {
       const char *TokPtr = Buffer;
       unsigned Len = PP.getSpelling(Tok, TokPtr);
       OS.write(TokPtr, Len);
 
       // Tokens that can contain embedded newlines need to adjust our current
       // line number.
       // FIXME: The token may end with a newline in which case
       // setEmittedDirectiveOnThisLine/setEmittedTokensOnThisLine afterwards is

clang/lib/Parse/ParseDecl.cpp

void Parser::ParseExternalSourceSymbolAttribute(
   if (T.consumeClose())
     return;
   if (EndLoc)
     *EndLoc = T.getCloseLocation();
 
   ArgsUnion Args[] = {Language.get(), DefinedInExpr.get(),
                       GeneratedDeclaration};
   Attrs.addNew(&ExternalSourceSymbol, SourceRange(Loc, T.getCloseLocation()),
-               ScopeName, ScopeLoc, Args, llvm::array_lengthof(Args), Syntax);
+               ScopeName, ScopeLoc, Args, std::size(Args), Syntax);
 }
 
 /// Parse the contents of the "objc_bridge_related" attribute.
 /// objc_bridge_related '(' related_class ',' opt-class_method ',' opt-instance_method ')'
 /// related_class:
 ///     Identifier
 ///
 /// opt-class_method:
void Parser::ParseSwiftNewTypeAttribute(
   // Closing ')'
   if (T.consumeClose())
     return;
   if (EndLoc)
     *EndLoc = T.getCloseLocation();
 
   ArgsUnion Args[] = {SwiftType};
   Attrs.addNew(&AttrName, SourceRange(AttrNameLoc, T.getCloseLocation()),
-               ScopeName, ScopeLoc, Args, llvm::array_lengthof(Args), Syntax);
+               ScopeName, ScopeLoc, Args, std::size(Args), Syntax);
 }
 
 void Parser::ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,
                                               SourceLocation AttrNameLoc,
                                               ParsedAttributes &Attrs,
                                               SourceLocation *EndLoc,
                                               IdentifierInfo *ScopeName,
                                               SourceLocation ScopeLoc,

clang/lib/Sema/DeclSpec.cpp

DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
 
   // new[] a parameter array if needed.
   if (NumParams) {
     // If the 'InlineParams' in Declarator is unused and big enough, put our
     // parameter list there (in an effort to avoid new/delete traffic).  If it
     // is already used (consider a function returning a function pointer) or too
     // small (function with too many parameters), go to the heap.
     if (!TheDeclarator.InlineStorageUsed &&
-        NumParams <= llvm::array_lengthof(TheDeclarator.InlineParams)) {
+        NumParams <= std::size(TheDeclarator.InlineParams)) {
       I.Fun.Params = TheDeclarator.InlineParams;
       new (I.Fun.Params) ParamInfo[NumParams];
       I.Fun.DeleteParams = false;
       TheDeclarator.InlineStorageUsed = true;
     } else {
       I.Fun.Params = new DeclaratorChunk::ParamInfo[NumParams];
       I.Fun.DeleteParams = true;
     }
void Declarator::setDecompositionBindings(
   Range.setEnd(RSquareLoc);
 
   // We're now past the identifier.
   SetIdentifier(nullptr, LSquareLoc);
   Name.EndLocation = RSquareLoc;
 
   // Allocate storage for bindings and stash them away.
   if (Bindings.size()) {
-    if (!InlineStorageUsed &&
-        Bindings.size() <= llvm::array_lengthof(InlineBindings)) {
+    if (!InlineStorageUsed && Bindings.size() <= std::size(InlineBindings)) {
       BindingGroup.Bindings = InlineBindings;
       BindingGroup.DeleteBindings = false;
       InlineStorageUsed = true;
     } else {
       BindingGroup.Bindings =
           new DecompositionDeclarator::Binding[Bindings.size()];
       BindingGroup.DeleteBindings = true;
     }

clang/lib/Sema/ParsedAttr.cpp

 namespace {
 
 #include "clang/Sema/AttrParsedAttrImpl.inc"
 
 } // namespace
 
 const ParsedAttrInfo &ParsedAttrInfo::get(const AttributeCommonInfo &A) {
   // If we have a ParsedAttrInfo for this ParsedAttr then return that.
-  if ((size_t)A.getParsedKind() < llvm::array_lengthof(AttrInfoMap))
+  if ((size_t)A.getParsedKind() < std::size(AttrInfoMap))
     return *AttrInfoMap[A.getParsedKind()];
 
   // If this is an ignored attribute then return an appropriate ParsedAttrInfo.
   static const ParsedAttrInfo IgnoredParsedAttrInfo(
       AttributeCommonInfo::IgnoredAttribute);
   if (A.getParsedKind() == AttributeCommonInfo::IgnoredAttribute)
     return IgnoredParsedAttrInfo;
 

clang/unittests/AST/CommentLexer.cpp

TEST_F(CommentLexerTest, Basic1) {
   ASSERT_EQ(0U, Toks.size());
 }
 
 // Empty comments should be handled.
 TEST_F(CommentLexerTest, Basic2) {
   const char *Sources[] = {
     "//", "///", "//!", "///<", "//!<"
   };
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(1U, Toks.size());
 
     ASSERT_EQ(tok::newline, Toks[0].getKind());
   }
 }
 
 // Empty comments should be handled.
 TEST_F(CommentLexerTest, Basic3) {
   const char *Sources[] = {
     "/**/", "/***/", "/*!*/", "/**<*/", "/*!<*/"
   };
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(2U, Toks.size());
 
     ASSERT_EQ(tok::newline, Toks[0].getKind());
     ASSERT_EQ(tok::newline, Toks[1].getKind());
   }
 }
 
 // Single comment with plain text.
 TEST_F(CommentLexerTest, Basic4) {
   const char *Sources[] = {
     "// Meow",   "/// Meow",    "//! Meow",
     "// Meow\n", "// Meow\r\n", "//! Meow\r",
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(2U, Toks.size());
 
     ASSERT_EQ(tok::text,          Toks[0].getKind());
     ASSERT_EQ(StringRef(" Meow"), Toks[0].getText());
 
     ASSERT_EQ(tok::newline,       Toks[1].getKind());
   }
 }
 
 // Single comment with plain text.
 TEST_F(CommentLexerTest, Basic5) {
   const char *Sources[] = {
     "/* Meow*/", "/** Meow*/",  "/*! Meow*/"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(3U, Toks.size());
 
     ASSERT_EQ(tok::text,          Toks[0].getKind());
     ASSERT_EQ(StringRef(" Meow"), Toks[0].getText());
 
     ASSERT_EQ(tok::newline,       Toks[1].getKind());
     ASSERT_EQ(tok::newline,       Toks[2].getKind());
   }
 }
 
 // Test newline escaping.
 TEST_F(CommentLexerTest, Basic6) {
   const char *Sources[] = {
     "// Aaa\\\n"   " Bbb\\ \n"   " Ccc?" "?/\n",
     "// Aaa\\\r\n" " Bbb\\ \r\n" " Ccc?" "?/\r\n",
     "// Aaa\\\r"   " Bbb\\ \r"   " Ccc?" "?/\r"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(10U, Toks.size());
 
     ASSERT_EQ(tok::text,         Toks[0].getKind());
     ASSERT_EQ(StringRef(" Aaa"), Toks[0].getText());
TEST_F(CommentLexerTest, Basic7) {
 
   ASSERT_EQ(tok::newline,      Toks[13].getKind());
   ASSERT_EQ(tok::newline,      Toks[14].getKind());
 }
 
 // A command marker followed by comment end.
 TEST_F(CommentLexerTest, DoxygenCommand1) {
   const char *Sources[] = { "//@", "///@", "//!@" };
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(2U, Toks.size());
 
     ASSERT_EQ(tok::text,          Toks[0].getKind());
     ASSERT_EQ(StringRef("@"),     Toks[0].getText());
 
     ASSERT_EQ(tok::newline,       Toks[1].getKind());
   }
 }
 
 // A command marker followed by comment end.
 TEST_F(CommentLexerTest, DoxygenCommand2) {
   const char *Sources[] = { "/*@*/", "/**@*/", "/*!@*/"};
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(3U, Toks.size());
 
     ASSERT_EQ(tok::text,          Toks[0].getKind());
     ASSERT_EQ(StringRef("@"),     Toks[0].getText());
 
     ASSERT_EQ(tok::newline,       Toks[1].getKind());
     ASSERT_EQ(tok::newline,       Toks[2].getKind());
   }
 }
 
 // A command marker followed by comment end.
 TEST_F(CommentLexerTest, DoxygenCommand3) {
   const char *Sources[] = { "/*\\*/", "/**\\*/" };
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(3U, Toks.size());
 
     ASSERT_EQ(tok::text,           Toks[0].getKind());
     ASSERT_EQ(StringRef("\\"),     Toks[0].getText());
TEST_F(CommentLexerTest, DoxygenCommand4) {
   };
   const char *Text[] = {
     " ",
     "\\", " ", "@", " ", "&", " ", "$",  " ", "#", " ",
     "<",  " ", ">", " ", "%", " ", "\"", " ", ".", " ",
     "::", ""
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
-    ASSERT_EQ(array_lengthof(Text), Toks.size());
+    ASSERT_EQ(std::size(Text), Toks.size());
 
     for (size_t j = 0, e = Toks.size(); j != e; j++) {
       if(Toks[j].is(tok::text)) {
         ASSERT_EQ(StringRef(Text[j]), Toks[j].getText())
           << "index " << i;
       }
     }
   }

 
 // Empty verbatim block.
 TEST_F(CommentLexerTest, VerbatimBlock1) {
   const char *Sources[] = {
     "/// \\verbatim\\endverbatim\n//",
     "/** \\verbatim\\endverbatim*/"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(5U, Toks.size());
 
     ASSERT_EQ(tok::text,                 Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),            Toks[0].getText());

 
 // Single-line verbatim block.
 TEST_F(CommentLexerTest, VerbatimBlock4) {
   const char *Sources[] = {
     "/// Meow \\verbatim aaa \\endverbatim\n//",
     "/** Meow \\verbatim aaa \\endverbatim*/"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(6U, Toks.size());
 
     ASSERT_EQ(tok::text,                 Toks[0].getKind());
     ASSERT_EQ(StringRef(" Meow "),       Toks[0].getText());

 
 // Single-line verbatim block without an end command.
 TEST_F(CommentLexerTest, VerbatimBlock5) {
   const char *Sources[] = {
     "/// Meow \\verbatim aaa \n//",
     "/** Meow \\verbatim aaa */"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(5U, Toks.size());
 
     ASSERT_EQ(tok::text,                 Toks[0].getKind());
     ASSERT_EQ(StringRef(" Meow "),       Toks[0].getText());

 
 // Empty verbatim line.
 TEST_F(CommentLexerTest, VerbatimLine1) {
   const char *Sources[] = {
     "/// \\fn\n//",
     "/** \\fn*/"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(4U, Toks.size());
 
     ASSERT_EQ(tok::text,               Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),          Toks[0].getText());
 
     ASSERT_EQ(tok::verbatim_line_name, Toks[1].getKind());
     ASSERT_EQ(StringRef("fn"),         getVerbatimLineName(Toks[1]));
 
     ASSERT_EQ(tok::newline,            Toks[2].getKind());
     ASSERT_EQ(tok::newline,            Toks[3].getKind());
   }
 }
 
 // Verbatim line with Doxygen escape sequences, which should not be expanded.
 TEST_F(CommentLexerTest, VerbatimLine2) {
   const char *Sources[] = {
     "/// \\fn void *foo(const char *zzz = \"\\$\");\n//",
     "/** \\fn void *foo(const char *zzz = \"\\$\");*/"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(5U, Toks.size());
 
     ASSERT_EQ(tok::text,               Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),          Toks[0].getText());

 }
 
 TEST_F(CommentLexerTest, HTML4) {
   const char *Sources[] = {
     "// <img",
     "// <img "
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(3U, Toks.size());
 
     ASSERT_EQ(tok::text,           Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),      Toks[0].getText());

 }
 
 TEST_F(CommentLexerTest, HTML9) {
   const char *Sources[] = {
     "// <img src",
     "// <img src "
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(4U, Toks.size());
 
     ASSERT_EQ(tok::text,           Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),      Toks[0].getText());

 }
 
 TEST_F(CommentLexerTest, HTML10) {
   const char *Sources[] = {
     "// <img src=",
     "// <img src ="
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(5U, Toks.size());
 
     ASSERT_EQ(tok::text,           Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),      Toks[0].getText());

 TEST_F(CommentLexerTest, HTML11) {
   const char *Sources[] = {
     "// <img src=\"",
     "// <img src = \"",
     "// <img src=\'",
     "// <img src = \'"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(6U, Toks.size());
 
     ASSERT_EQ(tok::text,               Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),          Toks[0].getText());

 TEST_F(CommentLexerTest, HTML13) {
   const char *Sources[] = {
     "// <img src=\"val\\\"\\'val",
     "// <img src=\"val\\\"\\'val\"",
     "// <img src=\'val\\\"\\'val",
     "// <img src=\'val\\\"\\'val\'"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(6U, Toks.size());
 
     ASSERT_EQ(tok::text,                  Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),             Toks[0].getText());

 }
 
 TEST_F(CommentLexerTest, HTML14) {
   const char *Sources[] = {
     "// <img src=\"val\\\"\\'val\">",
     "// <img src=\'val\\\"\\'val\'>"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(7U, Toks.size());
 
     ASSERT_EQ(tok::text,                  Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),             Toks[0].getText());

 }
 
 TEST_F(CommentLexerTest, HTML15) {
   const char *Sources[] = {
     "// <img/>",
     "// <img />"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(4U, Toks.size());
 
     ASSERT_EQ(tok::text,               Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),          Toks[0].getText());
 
     ASSERT_EQ(tok::html_start_tag,     Toks[1].getKind());
     ASSERT_EQ(StringRef("img"),        Toks[1].getHTMLTagStartName());
 
     ASSERT_EQ(tok::html_slash_greater, Toks[2].getKind());
 
     ASSERT_EQ(tok::newline,            Toks[3].getKind());
   }
 }
 
 TEST_F(CommentLexerTest, HTML16) {
   const char *Sources[] = {
     "// <img/ Aaa",
     "// <img / Aaa"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(5U, Toks.size());
 
     ASSERT_EQ(tok::text,               Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),          Toks[0].getText());

 TEST_F(CommentLexerTest, HTMLCharacterReferences16) {
   const char *Sources[] = {
     "// &#61;",
     "// &#x3d;",
     "// &#X3d;",
     "// &#X3D;"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     std::vector<Token> Toks;
 
     lexString(Sources[i], Toks);
 
     ASSERT_EQ(3U, Toks.size());
 
     ASSERT_EQ(tok::text,          Toks[0].getKind());
     ASSERT_EQ(StringRef(" "),     Toks[0].getText());

clang/unittests/AST/CommentParser.cpp

const char *Sources[] = {
 
     ("/**\n"
     " Aaa\n"
     "\t \n"
     " Bbb\n"
     "*/"),
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " Aaa"));
     ASSERT_TRUE(HasParagraphCommentAt(FC, 1, " Bbb"));
   }
 }
 
const char *Sources[] = {
     ("// \\param\n"
     "//     aaa Bbb\n"),
     ("// \\param \n"
     "//     aaa Bbb\n"),
     ("// \\param aaa\n"
     "// Bbb\n")
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       ParamCommandComment *PCC;
       ParagraphComment *PC;
       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
const char *Sources[] = {
     ("// \\param\n"
     "//     [in] aaa Bbb\n"),
     ("// \\param [in]\n"
     "//     aaa Bbb\n"),
     ("// \\param [in] aaa\n"
     "// Bbb\n"),
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       ParamCommandComment *PCC;
       ParagraphComment *PC;
       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
const char *Sources[] = {
     ("// \\param\n"
     "//     [out] aaa Bbb\n"),
     ("// \\param [out]\n"
     "//     aaa Bbb\n"),
     ("// \\param [out] aaa\n"
     "// Bbb\n"),
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       ParamCommandComment *PCC;
       ParagraphComment *PC;
       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
const char *Sources[] = {
     "// \\param [in,\n"
     "//     out] aaa Bbb\n",
     "// \\param [in,out]\n"
     "//     aaa Bbb\n",
     "// \\param [in,out] aaa\n"
     "// Bbb\n"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       ParamCommandComment *PCC;
       ParagraphComment *PC;
       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
const char *Sources[] = {
     "// \\tparam\n"
     "//     aaa Bbb\n",
     "// \\tparam \n"
     "//     aaa Bbb\n",
     "// \\tparam aaa\n"
     "// Bbb\n"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       TParamCommandComment *TPCC;
       ParagraphComment *PC;
       ASSERT_TRUE(HasTParamCommandAt(FC, Traits, 1, TPCC, "tparam",

 
 TEST_F(CommentParserTest, HTML1) {
   const char *Sources[] = {
     "// <a",
     "// <a>",
     "// <a >"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 1));
 
     {
       ParagraphComment *PC;
       HTMLStartTagComment *HST;
       ASSERT_TRUE(GetChildAt(FC, 0, PC));
 
       ASSERT_TRUE(HasChildCount(PC, 2));
         ASSERT_TRUE(HasTextAt(PC, 0, " "));
         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", NoAttrs()));
     }
   }
 }
 
 TEST_F(CommentParserTest, HTML2) {
   const char *Sources[] = {
     "// <br/>",
     "// <br />"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 1));
 
     {
       ParagraphComment *PC;
       HTMLStartTagComment *HST;
       ASSERT_TRUE(GetChildAt(FC, 0, PC));
 
       ASSERT_TRUE(HasChildCount(PC, 2));
         ASSERT_TRUE(HasTextAt(PC, 0, " "));
         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "br", SelfClosing()));
     }
   }
 }
 
 TEST_F(CommentParserTest, HTML3) {
   const char *Sources[] = {
     "// <a href",
     "// <a href ",
     "// <a href>",
     "// <a href >",
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 1));
 
     {
       ParagraphComment *PC;
       HTMLStartTagComment *HST;
       ASSERT_TRUE(GetChildAt(FC, 0, PC));
 
       ASSERT_TRUE(HasChildCount(PC, 2));
         ASSERT_TRUE(HasTextAt(PC, 0, " "));
         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", "href", ""));
     }
   }
 }
 
 TEST_F(CommentParserTest, HTML4) {
   const char *Sources[] = {
     "// <a href=\"bbb\"",
     "// <a href=\"bbb\">",
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 1));
 
     {
       ParagraphComment *PC;
       HTMLStartTagComment *HST;
       ASSERT_TRUE(GetChildAt(FC, 0, PC));
 
       ASSERT_TRUE(HasChildCount(PC, 2));
         ASSERT_TRUE(HasTextAt(PC, 0, " "));
         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", "href", "bbb"));
     }
   }
 }
 
 TEST_F(CommentParserTest, HTML5) {
   const char *Sources[] = {
     "// </a",
     "// </a>",
     "// </a >"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 1));
 
     {
       ParagraphComment *PC;
       HTMLEndTagComment *HET;
       ASSERT_TRUE(GetChildAt(FC, 0, PC));
 
const char *Sources[] = {
     "// Aaa\n"
     "//\\endverbatim\n",
 
     "/*\\verbatim\n"
     " * Aaa\n"
     " *\\endverbatim*/"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 1));
 
     {
       VerbatimBlockComment *VBC;
       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 0, VBC,
                                      "verbatim", "endverbatim",
                                      Lines(), " Aaa"));
     }
   }
 }
 
 TEST_F(CommentParserTest, VerbatimBlock6) {
   const char *Sources[] = {
     "// \\verbatim\n"
     "// Aaa\n"
     "// \\endverbatim\n",
 
     "/* \\verbatim\n"
     " * Aaa\n"
     " * \\endverbatim*/"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       VerbatimBlockComment *VBC;
       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
                                      "verbatim", "endverbatim",
const char *Sources[] = {
     "// \\endverbatim\n",
 
     "/* \\verbatim\n"
     " * Aaa\n"
     " * Bbb\n"
     " * \\endverbatim*/"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       VerbatimBlockComment *VBC;
       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
                                      "verbatim", "endverbatim",
const char *Sources[] = {
     "// \\endverbatim\n",
 
     "/* \\verbatim\n"
     " * Aaa\n"
     " *\n"
     " * Bbb\n"
     " * \\endverbatim*/"
   };
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       VerbatimBlockComment *VBC;
       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
                                      "verbatim", "endverbatim"));
       ASSERT_EQ(3U, VBC->getNumLines());
       ASSERT_EQ(" Aaa", VBC->getText(0));
       ASSERT_EQ("",     VBC->getText(1));
       ASSERT_EQ(" Bbb", VBC->getText(2));
     }
   }
 }
 
 TEST_F(CommentParserTest, VerbatimLine1) {
   const char *Sources[] = {
     "// \\fn",
     "// \\fn\n"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       VerbatimLineComment *VLC;
       ASSERT_TRUE(HasVerbatimLineAt(FC, Traits, 1, VLC, "fn", ""));
     }
   }
 }
 
 TEST_F(CommentParserTest, VerbatimLine2) {
   const char *Sources[] = {
     "/// \\fn void *foo(const char *zzz = \"\\$\");\n//",
     "/** \\fn void *foo(const char *zzz = \"\\$\");*/"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       VerbatimLineComment *VLC;
       ASSERT_TRUE(HasVerbatimLineAt(FC, Traits, 1, VLC, "fn",
                   " void *foo(const char *zzz = \"\\$\");"));
     }
   }
 }
 
 TEST_F(CommentParserTest, Deprecated) {
   const char *Sources[] = {
     "/** @deprecated*/",
     "/// @deprecated\n"
   };
 
-  for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
+  for (size_t i = 0, e = std::size(Sources); i != e; i++) {
     FullComment *FC = parseString(Sources[i]);
     ASSERT_TRUE(HasChildCount(FC, 2));
 
     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
     {
       BlockCommandComment *BCC;
       ParagraphComment *PC;
       ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "deprecated", PC));

clang/unittests/AST/DeclPrinterTest.cpp

TEST(DeclPrinter, TestCXXMethodDecl_Operator1) {
   const char *OperatorNames[] = {
     "+",  "-",  "*",  "/",  "%",  "^",   "&",   "|",
     "=",  "<",  ">",  "+=", "-=", "*=",  "/=",  "%=",
     "^=", "&=", "|=", "<<", ">>", ">>=", "<<=", "==",  "!=",
     "<=", ">=", "&&", "||",  ",", "->*",
     "()", "[]"
   };
 
-  for (unsigned i = 0, e = llvm::array_lengthof(OperatorNames); i != e; ++i) {
+  for (unsigned i = 0, e = std::size(OperatorNames); i != e; ++i) {
     SmallString<128> Code;
     Code.append("struct Z { void operator");
     Code.append(OperatorNames[i]);
     Code.append("(Z z); };");
 
     SmallString<128> Expected;
     Expected.append("void operator");
     Expected.append(OperatorNames[i]);
     Expected.append("(Z z)");
 
     ASSERT_TRUE(PrintedDeclCXX98Matches(
       Code,
       cxxMethodDecl(ofClass(hasName("Z"))).bind("id"),
       Expected));
   }
 }
 
 TEST(DeclPrinter, TestCXXMethodDecl_Operator2) {
   const char *OperatorNames[] = {
     "~", "!", "++", "--", "->"
   };
 
-  for (unsigned i = 0, e = llvm::array_lengthof(OperatorNames); i != e; ++i) {
+  for (unsigned i = 0, e = std::size(OperatorNames); i != e; ++i) {
     SmallString<128> Code;
     Code.append("struct Z { void operator");
     Code.append(OperatorNames[i]);
     Code.append("(); };");
 
     SmallString<128> Expected;
     Expected.append("void operator");
     Expected.append(OperatorNames[i]);

clang/unittests/Tooling/CompilationDatabaseTest.cpp

ASSERT_THAT(Result[0].CommandLine,
               ElementsAre(EndsWith("clang-tool"), "-c", "-DDEF3", "source"));
   EXPECT_EQ(2, Argc);
 }
 
 TEST(ParseFixedCompilationDatabase, HandlesPositionalArgsSyntaxOnly) {
   // Adjust the given command line arguments to ensure that any positional
   // arguments in them are stripped.
   const char *Argv[] = {"--", "somefile.cpp", "-fsyntax-only", "-DDEF3"};
-  int Argc = llvm::array_lengthof(Argv);
+  int Argc = std::size(Argv);
   std::string ErrorMessage;
   std::unique_ptr<CompilationDatabase> Database =
       FixedCompilationDatabase::loadFromCommandLine(Argc, Argv, ErrorMessage);
   ASSERT_TRUE((bool)Database);
   ASSERT_TRUE(ErrorMessage.empty());
   std::vector<CompileCommand> Result = Database->getCompileCommands("source");
   ASSERT_EQ(1ul, Result.size());
   ASSERT_EQ(".", Result[0].Directory);