[clang] NFC: Refactor custom class into a lambda in CompilerInvocation

[jansvoboda11]

Summary

Change makeFlagToValueNormalizer so that one specialization converts all integral/enum arguments into uint64_t and forwards them to the more generic version.

This makes it easy to replace the custom FlagToValueNormalizer struct with a lambda, which is the common approach in other (de)normalizers.

Finally, drop custom is_int_convertbile in favor of llvm::is_integral_or_enum.

[dexonsmith]

This looks like an improvement, so LGTM, but I have a couple of comments.

clang/lib/Frontend/CompilerInvocation.cpp

165–170

I missed the double negation here for a while; might be simpler as:

<std::is_same<T, uint64_t>::value ||
 !llvm::is_integral_or_neum<T>::value>

176–180

Ah, I guess you want this to match the above. I guess that's the benefit of the old is_int_convertible -- it didn't need double-negation to make it clear that the two functions were alternatives. I might prefer the previous option of having a stand-alone function (possibly renamed if you think the old name isn't correct anymore). (Regardless, you can drop the unnecessary parentheses.)

180

(not a behaviour change but) I wonder if this correct for signed types, where the conversion back to T could change sign if it's a negative value. Should there be an assertion that the value is >= 0? (Probably to do separately / outside this patch)

[jansvoboda11]

Extract SFINAE check into function again

[jansvoboda11]

clang/lib/Frontend/CompilerInvocation.cpp

180

It might be good to be defensive here. I'll put that into a follow-up.

clang/lib/Frontend/CompilerInvocation.cpp

 /// argument.
 static void denormalizeSimpleFlag(SmallVectorImpl<const char *> &Args,
                                   const char *Spelling,
                                   CompilerInvocation::StringAllocator,
                                   Option::OptionClass, unsigned, /*T*/...) {
   Args.push_back(Spelling);
 }
 
-namespace {
-template <typename T> struct FlagToValueNormalizer {
-  T Value;
+template <typename T> static constexpr bool is_uint64_t_convertible() {
+  return !std::is_same<T, uint64_t>::value &&
+         llvm::is_integral_or_enum<T>::value;
+}
 
-  Optional<T> operator()(OptSpecifier Opt, unsigned, const ArgList &Args,
-                         DiagnosticsEngine &) {
+template <typename T,
+          std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false>
+static auto makeFlagToValueNormalizer(T Value) {
+  return [Value](OptSpecifier Opt, unsigned, const ArgList &Args,
+                 DiagnosticsEngine &) -> Optional<T> {
     if (Args.hasArg(Opt))
       return Value;
     return None;
-  }
   };
-} // namespace
-
-template <typename T> static constexpr bool is_int_convertible() {
-  return sizeof(T) <= sizeof(uint64_t) &&
-         std::is_trivially_constructible<T, uint64_t>::value &&
-         std::is_trivially_constructible<uint64_t, T>::value;
-}
-
-template <typename T, std::enable_if_t<is_int_convertible<T>(), bool> = false>
-static FlagToValueNormalizer<uint64_t> makeFlagToValueNormalizer(T Value) {
-  return FlagToValueNormalizer<uint64_t>{Value};
 }
 
-template <typename T, std::enable_if_t<!is_int_convertible<T>(), bool> = false>
-static FlagToValueNormalizer<T> makeFlagToValueNormalizer(T Value) {
-  return FlagToValueNormalizer<T>{std::move(Value)};
+template <typename T,
+          std::enable_if_t<is_uint64_t_convertible<T>(), bool> = false>
+static auto makeFlagToValueNormalizer(T Value) {
+  return makeFlagToValueNormalizer(uint64_t(Value));
 }
 
 static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue,
                                         OptSpecifier OtherOpt) {
   return [Value, OtherValue, OtherOpt](OptSpecifier Opt, unsigned,
                                        const ArgList &Args,
                                        DiagnosticsEngine &) -> Optional<bool> {
     if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
       return A->getOption().matches(Opt) ? Value : OtherValue;