[flang] Restore ENUM_CLASS() to be compilation-time code

[klausler]

Summary

Rework some recent changes to the ENUM_CLASS() macro so that
all of the construction of enumerator-to-name string mapping
data structures is again performed at compilation time.

[klausler]

Update counting algorithm to get n==1 case right.

[Renaud-K]

Consider this program:

#include "enum_class.h"
#include <iostream>

ENUM_CLASS(RelationalOperator, LT, LE, EQ, NE, GE, GT)

int main() {
  std::cout << EnumToString(RelationalOperator::LT) << std::endl;
  std::cout << EnumToString(RelationalOperator::LE) << std::endl;
  std::cout << EnumToString(RelationalOperator::EQ) << std::endl;
  std::cout << EnumToString(RelationalOperator::NE) << std::endl;
  std::cout << EnumToString(RelationalOperator::GE) << std::endl;
  std::cout << EnumToString(RelationalOperator::GT) << std::endl;
  return 0;
}

Then compile it gcc 9.3.0

g++ flang_main.cpp -std=c++17 -g -O2 -fno-inline
gdb a.out
b enum_class.h:43
r
Breakpoint 1, Fortran::common::EnumNames<6ul> (p=0x555555555648 "LT, LE, EQ, NE, GE, GT") at enum_class.h:43
43        for (; *p; ++p) {

Is this expected?

[klausler]

Convert return type to std::string_view, which is more compatible with constexpr than std::string.

Adjust a few call sites where this made a difference.

[tschuett]

What happens if I have 2 ENUM_CLASS? You did not namespace Enum2String. There are no tests.

[klausler]

In D137859#3922948, @tschuett wrote:

What happens if I have 2 ENUM_CLASS? You did not namespace Enum2String. There are no tests.

This is not a new feature, just a rework of a recent update to it. It should work as it always has.

Multiple instances of ENUM_CLASS in the same scope are distinguished by the name of the ENUM_CLASS.

EnumToString will be defined in the namespace and/or class in which the reference to the ENUM_CLASS macro appears.

[tschuett]

In D137859#3923213, @klausler wrote:

In D137859#3922948, @tschuett wrote:

What happens if I have 2 ENUM_CLASS? You did not namespace Enum2String. There are no tests.

This is not a new feature, just a rework of a recent update to it. It should work as it always has.

Multiple instances of ENUM_CLASS in the same scope are distinguished by the name of the ENUM_CLASS.

EnumToString will be defined in the namespace and/or class in which the reference to the ENUM_CLASS macro appears.

Agreed. But you could still end up with two EnumToString in the same *context*. The only difference is the type of the parameter.

ENUM_CLASS(RelationalOperator, LT, LE, EQ, NE, GE, GT);
ENUM_CLASS(RelationalOperator2, LT, LE, EQ, NE, GE, GT);

[klausler]

In D137859#3923215, @tschuett wrote:

In D137859#3923213, @klausler wrote:

In D137859#3922948, @tschuett wrote:

What happens if I have 2 ENUM_CLASS? You did not namespace Enum2String. There are no tests.

This is not a new feature, just a rework of a recent update to it. It should work as it always has.

Multiple instances of ENUM_CLASS in the same scope are distinguished by the name of the ENUM_CLASS.

EnumToString will be defined in the namespace and/or class in which the reference to the ENUM_CLASS macro appears.

Agreed. But you could still end up with two EnumToString in the same *context*. The only difference is the type of the parameter.

ENUM_CLASS(RelationalOperator, LT, LE, EQ, NE, GE, GT);
ENUM_CLASS(RelationalOperator2, LT, LE, EQ, NE, GE, GT);

In that case, the difference in the parameter types is sufficient to distinguish the two functions by the usual C++ function overloading rules.

#include "enum-class.h"
#include <iostream>
ENUM_CLASS(RelationalOperator, LT, LE, EQ, NE, GE, GT)
ENUM_CLASS(RelationalOperator2, LT, LE, EQ, NE, GE, GT)
int main() {
  std::cout << EnumToString(RelationalOperator::LT) << std::endl;
  std::cout << EnumToString(RelationalOperator2::LT) << std::endl;
}

LT
LT

[Renaud-K]

Why do you say "Restore compile time code" in the review title? EnumToString never was compite-ime until now.

[klausler]

In D137859#3923388, @Renaud-K wrote:

Why do you say "Restore compile time code" in the review title? EnumToString never was compite-ime until now.

I mean that the construction of the tables used by EnumToString() should now take place at compilation time rather than needing execution-time allocation and initialization.

[Renaud-K]

Looks good.
Thank you.

flang/include/flang/Common/enum-class.h

+//===-- include/flang/Common/enum-class.h -----------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// The macro
+//   ENUM_CLASS(className, enum1, enum2, ..., enumN)
+// defines
+//   enum class className { enum1, enum2, ... , enumN };
+// as well as the introspective utilities
+//   static constexpr std::size_t className_enumSize{N};
+//   static inline const std::string &EnumToString(className);
+
+#ifndef FORTRAN_COMMON_ENUM_CLASS_H_
+#define FORTRAN_COMMON_ENUM_CLASS_H_
+
+#include <array>
+#include <string>
+
+namespace Fortran::common {
+
+constexpr std::size_t CountEnumNames(const char *p) {
+  std::size_t n{0};
+  std::size_t any{0};
+  for (; *p; ++p) {
+    if (*p == ',') {
+      n += any;
+      any = 0;
+    } else if (*p != ' ') {
+      any = 1;
+    }
+  }
+  return n + any;
+}
+
+template <std::size_t ITEMS>
+constexpr std::array<std::string_view, ITEMS> EnumNames(const char *p) {
+  std::array<std::string_view, ITEMS> result{""};
+  std::size_t at{0};
+  const char *start{nullptr};
+  for (; *p; ++p) {
+    if (*p == ',' || *p == ' ') {
+      if (start) {
+        result[at++] =
+            std::string_view{start, static_cast<std::size_t>(p - start)};
+        start = nullptr;
+      }
+    } else if (!start) {
+      start = p;
+    }
+  }
+  if (start) {
+    result[at] = std::string_view{start, static_cast<std::size_t>(p - start)};
+  }
+  return result;
+}
+
+#define ENUM_CLASS(NAME, ...) \
+  enum class NAME { __VA_ARGS__ }; \
+  [[maybe_unused]] static constexpr std::size_t NAME##_enumSize{ \
+      ::Fortran::common::CountEnumNames(#__VA_ARGS__)}; \
+  [[maybe_unused]] static inline std::string_view EnumToString(NAME e) { \
+    static const constexpr char vaArgs[]{#__VA_ARGS__}; \
+    static const constexpr auto names{ \
+        ::Fortran::common::EnumNames<NAME##_enumSize>(vaArgs)}; \
+    return names[static_cast<std::size_t>(e)]; \
+  }
+
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_ENUM_CLASS_H_

flang/include/flang/Common/enum-set.h

template <typename FUNC> void IterateOverMembers(const FUNC &f) const {
     while (auto least{copy.LeastElement()}) {
       f(*least);
       copy.erase(*least);
     }
   }
 
   template <typename STREAM>
   STREAM &Dump(
-      STREAM &o, const std::string &EnumToString(enumerationType)) const {
+      STREAM &o, std::string_view EnumToString(enumerationType)) const {
     char sep{'{'};
     IterateOverMembers([&](auto e) {
       o << sep << EnumToString(e);
       sep = ',';
     });
     return o << (sep == '{' ? "{}" : "}");
   }
 

flang/include/flang/Common/idioms.h

 #endif
 #if __cplusplus < 201703L
 #error this is a C++17 program
 #endif
 #if !__clang__ && defined __GNUC__ && __GNUC__ < 7
 #error g++ >= 7.2 is required
 #endif
 
+#include "enum-class.h"
 #include "visit.h"
 #include <array>
 #include <functional>
 #include <list>
 #include <memory>
 #include <optional>
 #include <string>
 #include <tuple>

 void BuildIndexToString(
     const char *commaSeparated, std::string enumNames[], int enumSize);
 
 template <typename A> struct ListItemCount {
   constexpr ListItemCount(std::initializer_list<A> list) : value{list.size()} {}
   const std::size_t value;
 };
 
-#define ENUM_CLASS(NAME, ...) \
-  enum class NAME { __VA_ARGS__ }; \
-  [[maybe_unused]] static constexpr std::size_t NAME##_enumSize{[] { \
-    enum { __VA_ARGS__ }; \
-    return Fortran::common::ListItemCount{__VA_ARGS__}.value; \
-  }()}; \
-  struct NAME##_struct { \
-    NAME##_struct(const NAME##_struct &) = delete; \
-    NAME##_struct &operator=(const NAME##_struct &) = delete; \
-    static NAME##_struct &instance() { \
-      static NAME##_struct s; \
-      return s; \
-    } \
-    std::array<std::string, NAME##_enumSize> _enumNames; \
-\
-  private: \
-    NAME##_struct() { \
-      Fortran::common::BuildIndexToString( \
-          #__VA_ARGS__, _enumNames.data(), NAME##_enumSize); \
-    } \
-    ~NAME##_struct() {} \
-  }; \
-  [[maybe_unused]] static inline const std::string &EnumToString(NAME e) { \
-    return NAME##_struct::instance()._enumNames[static_cast<int>(e)]; \
-  }
-
 // Check that a pointer is non-null and dereference it
 #define DEREF(p) Fortran::common::Deref(p, __FILE__, __LINE__)
 
 template <typename T> constexpr T &Deref(T *p, const char *file, int line) {
   if (!p) {
     Fortran::common::die("nullptr dereference at %s(%d)", file, line);
   }
   return *p;

flang/include/flang/Evaluate/type.h

 constexpr bool IsLengthlessIntrinsicType{
     common::HasMember<T, LengthlessIntrinsicTypes>};
 
 // Represents a type of any supported kind within a particular category.
 template <TypeCategory CATEGORY> struct SomeKind {
   static constexpr TypeCategory category{CATEGORY};
   constexpr bool operator==(const SomeKind &) const { return true; }
   static std::string AsFortran() {
-    return "Some"s + common::EnumToString(category);
+    return "Some"s + std::string{common::EnumToString(category)};
   }
 };
 
 using NumericCategoryTypes = std::tuple<SomeKind<TypeCategory::Integer>,
     SomeKind<TypeCategory::Real>, SomeKind<TypeCategory::Complex>>;
 using AllIntrinsicCategoryTypes = std::tuple<SomeKind<TypeCategory::Integer>,
     SomeKind<TypeCategory::Real>, SomeKind<TypeCategory::Complex>,
     SomeKind<TypeCategory::Character>, SomeKind<TypeCategory::Logical>>;

flang/include/flang/Parser/characters.h

 inline constexpr char ToLowerCaseLetter(char ch) {
   return IsUpperCaseLetter(ch) ? ch - 'A' + 'a' : ch;
 }
 
 inline constexpr char ToLowerCaseLetter(char &&ch) {
   return IsUpperCaseLetter(ch) ? ch - 'A' + 'a' : ch;
 }
 
-inline std::string ToLowerCaseLetters(const std::string &str) {
+inline std::string ToLowerCaseLetters(std::string_view str) {
   std::string lowered{str};
   for (char &ch : lowered) {
     ch = ToLowerCaseLetter(ch);
   }
   return lowered;
 }
 
 inline constexpr char ToUpperCaseLetter(char ch) {
   return IsLowerCaseLetter(ch) ? ch - 'a' + 'A' : ch;
 }
 
 inline constexpr char ToUpperCaseLetter(char &&ch) {
   return IsLowerCaseLetter(ch) ? ch - 'a' + 'A' : ch;
 }
 
-inline std::string ToUpperCaseLetters(const std::string &str) {
+inline std::string ToUpperCaseLetters(std::string_view str) {
   std::string raised{str};
   for (char &ch : raised) {
     ch = ToUpperCaseLetter(ch);
   }
   return raised;
 }
 
 inline constexpr bool IsSameApartFromCase(char x, char y) {

flang/include/flang/Parser/dump-parse-tree.h

explicit ParseTreeDumper(llvm::raw_ostream &out,
       const AnalyzedObjectsAsFortran *asFortran = nullptr)
       : out_(out), asFortran_{asFortran} {}
 
   static constexpr const char *GetNodeName(const char *) { return "char *"; }
 #define NODE_NAME(T, N) \
   static constexpr const char *GetNodeName(const T &) { return N; }
 #define NODE_ENUM(T, E) \
   static std::string GetNodeName(const T::E &x) { \
-    return #E " = "s + T::EnumToString(x); \
+    return #E " = "s + std::string{T::EnumToString(x)}; \
   }
 #define NODE(T1, T2) NODE_NAME(T1::T2, #T2)
   NODE_NAME(bool, "bool")
   NODE_NAME(int, "int")
   NODE(std, string)
   NODE(std, int64_t)
   NODE(std, uint64_t)
   NODE(format, ControlEditDesc)

flang/include/flang/Parser/message.h

 }
 constexpr MessageFixedText operator""_en_US(const char str[], std::size_t n) {
   return MessageFixedText{str, n, Severity::None};
 }
 } // namespace literals
 
 // The construction of a MessageFormattedText uses a MessageFixedText
 // as a vsnprintf() formatting string that is applied to the
-// following arguments.  CharBlock and std::string argument
-// values are also supported; they are automatically converted into
-// char pointers that are suitable for '%s' formatting.
+// following arguments.  CharBlock, std::string, and std::string_view
+// argument values are also supported; they are automatically converted
+// into char pointers that are suitable for '%s' formatting.
 class MessageFormattedText {
 public:
   template <typename... A>
   MessageFormattedText(const MessageFixedText &text, A &&...x)
       : severity_{text.severity()} {
     Format(&text, Convert(std::forward<A>(x))...);
   }
   MessageFormattedText(const MessageFormattedText &) = default;

 
 private:
   void Format(const MessageFixedText *, ...);
 
   template <typename A> A Convert(const A &x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return x;
   }
-  template <typename A> A Convert(A &x) {
-    static_assert(!std::is_class_v<std::decay_t<A>>);
-    return x;
-  }
   template <typename A> common::IfNoLvalue<A, A> Convert(A &&x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return std::move(x);
   }
   const char *Convert(const char *s) { return s; }
   const char *Convert(char *s) { return s; }
   const char *Convert(const std::string &);
-  const char *Convert(std::string &);
   const char *Convert(std::string &&);
+  const char *Convert(const std::string_view &);
+  const char *Convert(std::string_view &&);
   const char *Convert(CharBlock);
   std::intmax_t Convert(std::int64_t x) { return x; }
   std::uintmax_t Convert(std::uint64_t x) { return x; }
 
   Severity severity_;
   std::string string_;
   std::forward_list<std::string> conversions_; // preserves created strings
 };

flang/lib/Common/idioms.cpp

 //===-- lib/Common/idioms.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/Common/idioms.h"
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
-#include <regex>
 
 namespace Fortran::common {
 
 [[noreturn]] void die(const char *msg, ...) {
   va_list ap;
   va_start(ap, msg);
   std::fputs("\nfatal internal error: ", stderr);
   std::vfprintf(stderr, msg, ap);
   va_end(ap);
   fputc('\n', stderr);
   std::abort();
 }
 
-// Converts the comma separated list of enumerators into tokens which are then
-// stored into the provided array of strings. This is intended for use from the
-// expansion of ENUM_CLASS.
-void BuildIndexToString(
-    const char *commaSeparated, std::string enumNames[], int enumSize) {
-  std::string input(commaSeparated);
-  std::regex reg("\\s*,\\s*");
-
-  std::sregex_token_iterator iter(input.begin(), input.end(), reg, -1);
-  std::sregex_token_iterator end;
-  int index = 0;
-  while (iter != end) {
-    enumNames[index] = *iter;
-    iter++;
-    index++;
-  }
-  CHECK(index == enumSize);
-}
 } // namespace Fortran::common

flang/lib/Evaluate/characteristics.cpp

bool Procedure::IsCompatibleWith(const Procedure &actual, std::string *whyNot,
   }
   Attrs differences{attrs ^ actualAttrs};
   differences.reset(Attr::Subroutine); // dealt with specifically later
   if (!differences.empty()) {
     if (whyNot) {
       auto sep{": "s};
       *whyNot = "incompatible procedure attributes";
       differences.IterateOverMembers([&](Attr x) {
-        *whyNot += sep + EnumToString(x);
+        *whyNot += sep + std::string{EnumToString(x)};
         sep = ", ";
       });
     }
   } else if ((IsFunction() && actual.IsSubroutine()) ||
       (IsSubroutine() && actual.IsFunction())) {
     if (whyNot) {
       *whyNot =
           "incompatible procedures: one is a function, the other a subroutine";

flang/lib/Lower/IO.cpp

mlir::Value genInquireSpec<Fortran::parser::InquireSpec::CharVar>(
   mlir::FunctionType specFuncTy = specFunc.getFunctionType();
   const auto *varExpr = Fortran::semantics::GetExpr(
       std::get<Fortran::parser::ScalarDefaultCharVariable>(var.t));
   fir::ExtendedValue str = converter.genExprAddr(loc, varExpr, stmtCtx);
   llvm::SmallVector<mlir::Value> args = {
       builder.createConvert(loc, specFuncTy.getInput(0), cookie),
       builder.createIntegerConstant(
           loc, specFuncTy.getInput(1),
-          Fortran::runtime::io::HashInquiryKeyword(
+          Fortran::runtime::io::HashInquiryKeyword(std::string{
               Fortran::parser::InquireSpec::CharVar::EnumToString(
-                  std::get<Fortran::parser::InquireSpec::CharVar::Kind>(var.t))
+                  std::get<Fortran::parser::InquireSpec::CharVar::Kind>(var.t))}
                                                        .c_str())),
       builder.createConvert(loc, specFuncTy.getInput(2), fir::getBase(str)),
       builder.createConvert(loc, specFuncTy.getInput(3), fir::getLen(str))};
   return builder.create<fir::CallOp>(loc, specFunc, args).getResult(0);
 }
 /// Specialization for INTEGER.
 template <>
 mlir::Value genInquireSpec<Fortran::parser::InquireSpec::IntVar>(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
fir::emitFatalError(loc,
                         "internal error: expected a memory reference type");
   auto width = eleTy.cast<mlir::IntegerType>().getWidth();
   mlir::IndexType idxTy = builder.getIndexType();
   mlir::Value kind = builder.createIntegerConstant(loc, idxTy, width / 8);
   llvm::SmallVector<mlir::Value> args = {
       builder.createConvert(loc, specFuncTy.getInput(0), cookie),
       builder.createIntegerConstant(
           loc, specFuncTy.getInput(1),
-          Fortran::runtime::io::HashInquiryKeyword(
+          Fortran::runtime::io::HashInquiryKeyword(std::string{
               Fortran::parser::InquireSpec::IntVar::EnumToString(
-                  std::get<Fortran::parser::InquireSpec::IntVar::Kind>(var.t))
+                  std::get<Fortran::parser::InquireSpec::IntVar::Kind>(var.t))}
                                                        .c_str())),
       builder.createConvert(loc, specFuncTy.getInput(2), addr),
       builder.createConvert(loc, specFuncTy.getInput(3), kind)};
   return builder.create<fir::CallOp>(loc, specFunc, args).getResult(0);
 }
 /// Specialization for LOGICAL and (PENDING + ID).
 template <>
 mlir::Value genInquireSpec<Fortran::parser::InquireSpec::LogVar>(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
mlir::Value addr = fir::getBase(converter.genExprAddr(
       stmtCtx));
   llvm::SmallVector<mlir::Value> args = {
       builder.createConvert(loc, specFuncTy.getInput(0), cookie)};
   if (pendId)
     args.push_back(builder.createConvert(loc, specFuncTy.getInput(1), idExpr));
   else
     args.push_back(builder.createIntegerConstant(
         loc, specFuncTy.getInput(1),
-        Fortran::runtime::io::HashInquiryKeyword(
-            Fortran::parser::InquireSpec::LogVar::EnumToString(logVarKind)
+        Fortran::runtime::io::HashInquiryKeyword(std::string{
+            Fortran::parser::InquireSpec::LogVar::EnumToString(logVarKind)}
                                                      .c_str())));
   args.push_back(builder.createConvert(loc, specFuncTy.getInput(2), addr));
   auto call = builder.create<fir::CallOp>(loc, specFunc, args);
   boolRefToLogical(loc, builder, addr);
   return call.getResult(0);
 }
 
 /// If there is an IdExpr in the list of inquire-specs, then lower it and return
 /// the resulting Value. Otherwise, return null.

flang/lib/Parser/message.cpp

#endif
   conversions_.clear();
 }
 
 const char *MessageFormattedText::Convert(const std::string &s) {
   conversions_.emplace_front(s);
   return conversions_.front().c_str();
 }
 
-const char *MessageFormattedText::Convert(std::string &s) {
+const char *MessageFormattedText::Convert(std::string &&s) {
+  conversions_.emplace_front(std::move(s));
+  return conversions_.front().c_str();
+}
+
+const char *MessageFormattedText::Convert(const std::string_view &s) {
   conversions_.emplace_front(s);
   return conversions_.front().c_str();
 }
 
-const char *MessageFormattedText::Convert(std::string &&s) {
-  conversions_.emplace_front(std::move(s));
+const char *MessageFormattedText::Convert(std::string_view &&s) {
+  conversions_.emplace_front(s);
   return conversions_.front().c_str();
 }
 
 const char *MessageFormattedText::Convert(CharBlock x) {
   return Convert(x.ToString());
 }
 
 std::string MessageExpectedText::ToString() const {

flang/lib/Parser/unparse.cpp

 private:
   void Put(char);
   void Put(const char *);
   void Put(const std::string &);
   void PutNormalized(const std::string &);
   void PutKeywordLetter(char);
   void Word(const char *);
   void Word(const std::string &);
+  void Word(const std::string_view &);
   void Indent() { indent_ += indentationAmount_; }
   void Outdent() {
     CHECK(indent_ >= indentationAmount_);
     indent_ -= indentationAmount_;
   }
   void BeginOpenMP() { openmpDirective_ = true; }
   void EndOpenMP() { openmpDirective_ = false; }
   void BeginOpenACC() { openaccDirective_ = true; }

 void UnparseVisitor::Word(const char *str) {
   for (; *str != '\0'; ++str) {
     PutKeywordLetter(*str);
   }
 }
 
 void UnparseVisitor::Word(const std::string &str) { Word(str.c_str()); }
 
+void UnparseVisitor::Word(const std::string_view &str) {
+  for (std::size_t j{0}; j < str.length(); ++j) {
+    PutKeywordLetter(str[j]);
+  }
+}
+
 template <typename A>
 void Unparse(llvm::raw_ostream &out, const A &root, Encoding encoding,
     bool capitalizeKeywords, bool backslashEscapes,
     preStatementType *preStatement, AnalyzedObjectsAsFortran *asFortran) {
   UnparseVisitor visitor{out, 1, encoding, capitalizeKeywords, backslashEscapes,
       preStatement, asFortran};
   Walk(root, visitor);
   visitor.Done();
 }
 
 template void Unparse<Program>(llvm::raw_ostream &, const Program &, Encoding,
     bool, bool, preStatementType *, AnalyzedObjectsAsFortran *);
 template void Unparse<Expr>(llvm::raw_ostream &, const Expr &, Encoding, bool,
     bool, preStatementType *, AnalyzedObjectsAsFortran *);
 } // namespace Fortran::parser

flang/lib/Semantics/attr.cpp

case Attr::BIND_C:
     return "BIND(C)";
   case Attr::INTENT_IN:
     return "INTENT(IN)";
   case Attr::INTENT_INOUT:
     return "INTENT(INOUT)";
   case Attr::INTENT_OUT:
     return "INTENT(OUT)";
   default:
-    return EnumToString(attr);
+    return std::string{EnumToString(attr)};
   }
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &o, Attr attr) {
   return o << AttrToString(attr);
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const Attrs &attrs) {

flang/lib/Semantics/expression.cpp

 // tightly coupled with their typed representations in lib/Evaluate,
 // and appears here in namespace Fortran::evaluate for convenience.
 namespace Fortran::evaluate {
 
 using common::LanguageFeature;
 using common::NumericOperator;
 using common::TypeCategory;
 
-static inline std::string ToUpperCase(const std::string &str) {
+static inline std::string ToUpperCase(std::string_view str) {
   return parser::ToUpperCaseLetters(str);
 }
 
 struct DynamicTypeWithLength : public DynamicType {
   explicit DynamicTypeWithLength(const DynamicType &t) : DynamicType{t} {}
   std::optional<Expr<SubscriptInteger>> LEN() const;
   std::optional<Expr<SubscriptInteger>> length;
 };

flang/lib/Semantics/mod-file.cpp

 static void PutShape(
     llvm::raw_ostream &, const ArraySpec &, char open, char close);
 llvm::raw_ostream &PutAttrs(llvm::raw_ostream &, Attrs,
     const std::string * = nullptr, std::string before = ","s,
     std::string after = ""s);
 
 static llvm::raw_ostream &PutAttr(llvm::raw_ostream &, Attr);
 static llvm::raw_ostream &PutType(llvm::raw_ostream &, const DeclTypeSpec &);
-static llvm::raw_ostream &PutLower(llvm::raw_ostream &, const std::string &);
+static llvm::raw_ostream &PutLower(llvm::raw_ostream &, std::string_view);
 static std::error_code WriteFile(
     const std::string &, const std::string &, bool = true);
 static bool FileContentsMatch(
     const std::string &, const std::string &, const std::string &);
 static std::string CheckSum(const std::string_view &);
 
 // Collect symbols needed for a subprogram interface
 class SubprogramSymbolCollector {

 llvm::raw_ostream &PutAttr(llvm::raw_ostream &os, Attr attr) {
   return PutLower(os, AttrToString(attr));
 }
 
 llvm::raw_ostream &PutType(llvm::raw_ostream &os, const DeclTypeSpec &type) {
   return PutLower(os, type.AsFortran());
 }
 
-llvm::raw_ostream &PutLower(llvm::raw_ostream &os, const std::string &str) {
+llvm::raw_ostream &PutLower(llvm::raw_ostream &os, std::string_view str) {
   for (char c : str) {
     os << parser::ToLowerCaseLetter(c);
   }
   return os;
 }
 
 struct Temp {
   Temp(int fd, std::string path) : fd{fd}, path{path} {}

flang/lib/Semantics/symbol.cpp

 
 bool GenericKind::IsOperator() const {
   return IsDefinedOperator() || IsIntrinsicOperator();
 }
 
 std::string GenericKind::ToString() const {
   return common::visit(
       common::visitors {
-        [](const OtherKind &x) { return EnumToString(x); },
+        [](const OtherKind &x) { return std::string{EnumToString(x)}; },
             [](const DefinedIo &x) { return AsFortran(x).ToString(); },
 #if !__clang__ && __GNUC__ == 7 && __GNUC_MINOR__ == 2
             [](const common::NumericOperator &x) {
-              return common::EnumToString(x);
+              return std::string{common::EnumToString(x)};
             },
             [](const common::LogicalOperator &x) {
-              return common::EnumToString(x);
+              return std::string{common::EnumToString(x)};
             },
             [](const common::RelationalOperator &x) {
-              return common::EnumToString(x);
+              return std::string{common::EnumToString(x)};
             },
 #else
-            [](const auto &x) { return common::EnumToString(x); },
+            [](const auto &x) { return std::string{common::EnumToString(x)}; },
 #endif
       },
       u);
 }
 
 SourceName GenericKind::AsFortran(DefinedIo x) {
   const char *name{nullptr};
   switch (x) {