[Flang][flang-omp-report] Switch from std::string to StringRef (where possible)

[josh.mottley.arm]

Summary

This patch makes the following changes to flang-omp-report:

• Update 'normalize_clause_name' parameter to use llvm::StringRef instead of std::sting.
• Change usages of std::tolower to llvm::toLower from "ADT/StringExtras.h".

This is a one of several patches focusing on switching containers from STL to LLVM's ADT library.

[Leporacanthicus]

LGTM

flang/examples/flang-omp-report-plugin/flang-omp-report-visitor.h

 //===-- examples/flang-omp-report-plugin/flang-omp-report-visitor.h -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_FLANG_OMP_REPORT_VISITOR_H
 #define FORTRAN_FLANG_OMP_REPORT_VISITOR_H
 
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Parser/parsing.h"
 
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 
 #include <deque>
 #include <map>
 #include <string>
 
 namespace Fortran {
 namespace parser {
 struct ClauseInfo {

 bool operator==(const LogRecord &a, const LogRecord &b);
 bool operator!=(const LogRecord &a, const LogRecord &b);
 
 using OmpWrapperType =
     std::variant<const OpenMPConstruct *, const OpenMPDeclarativeConstruct *>;
 
 struct OpenMPCounterVisitor {
   std::string normalize_construct_name(std::string s);
-  ClauseInfo normalize_clause_name(const std::string &s);
+  ClauseInfo normalize_clause_name(const llvm::StringRef s);
   SourcePosition getLocation(const OmpWrapperType &w);
   SourcePosition getLocation(const OpenMPDeclarativeConstruct &c);
   SourcePosition getLocation(const OpenMPConstruct &c);
 
   std::string getName(const OmpWrapperType &w);
   std::string getName(const OpenMPDeclarativeConstruct &c);
   std::string getName(const OpenMPConstruct &c);
 

flang/examples/flang-omp-report-plugin/flang-omp-report-visitor.cpp

 //===-- examples/flang-omp-report-plugin/flang-omp-report-visitor.cpp -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang-omp-report-visitor.h"
+#include "llvm/ADT/StringExtras.h"
 
 namespace Fortran {
 namespace parser {
 bool operator<(const ClauseInfo &a, const ClauseInfo &b) {
   return a.clause < b.clause;
 }
 bool operator==(const ClauseInfo &a, const ClauseInfo &b) {
   return a.clause == b.clause && a.clauseDetails == b.clauseDetails;
 }
 bool operator!=(const ClauseInfo &a, const ClauseInfo &b) { return !(a == b); }
 
 bool operator==(const LogRecord &a, const LogRecord &b) {
   return a.file == b.file && a.line == b.line && a.construct == b.construct &&
       a.clauses == b.clauses;
 }
 bool operator!=(const LogRecord &a, const LogRecord &b) { return !(a == b); }
 
 std::string OpenMPCounterVisitor::normalize_construct_name(std::string s) {
   std::transform(s.begin(), s.end(), s.begin(),
-      [](unsigned char c) { return std::tolower(c); });
+      [](unsigned char c) { return llvm::toLower(c); });
   return s;
 }
-ClauseInfo OpenMPCounterVisitor::normalize_clause_name(const std::string &s) {
+ClauseInfo OpenMPCounterVisitor::normalize_clause_name(
+    const llvm::StringRef s) {
   std::size_t start = s.find('(');
   std::size_t end = s.find(')');
   std::string clauseName;
-  if (start != std::string::npos && end != std::string::npos) {
+  if (start != llvm::StringRef::npos && end != llvm::StringRef::npos) {
     clauseName = s.substr(0, start);
     clauseDetails = s.substr(start + 1, end - start - 1);
   } else {
     clauseName = s;
   }
   std::transform(clauseName.begin(), clauseName.end(), clauseName.begin(),
-      [](unsigned char c) { return std::tolower(c); });
+      [](unsigned char c) { return llvm::toLower(c); });
   std::transform(clauseDetails.begin(), clauseDetails.end(),
-      clauseDetails.begin(), [](unsigned char c) { return std::tolower(c); });
+      clauseDetails.begin(), [](unsigned char c) { return llvm::toLower(c); });
   return ClauseInfo{clauseName, clauseDetails};
 }
 SourcePosition OpenMPCounterVisitor::getLocation(const OmpWrapperType &w) {
   if (auto *val = std::get_if<const OpenMPConstruct *>(&w)) {
     const OpenMPConstruct *o{*val};
     return getLocation(*o);
   }
   return getLocation(*std::get<const OpenMPDeclarativeConstruct *>(w));