[flang][NFC] Address MSVC build warnings

[klausler]

Summary

Attempt to placate MSVC at several code sites in the flang compiler
(not incl. tests) where it's producing some build-time warnings.
Also address some build problems with Clang 16.0.3 hit while testing.

(Will wait to see MSVC CI build results and confirm that warnings have
been reduced before merging, of course. I may need to iterate.)

flang/include/flang/Evaluate/expression.h

   static void Deleter(GenericAssignmentWrapper *);
   std::optional<Assignment> v; // vacant if error
 };
 
 FOR_EACH_CATEGORY_TYPE(extern template class Expr, )
-FOR_EACH_TYPE_AND_KIND(extern template class ExpressionBase, )
+FOR_EACH_INTRINSIC_KIND(extern template class ExpressionBase, )
+FOR_EACH_CATEGORY_TYPE(extern template class ExpressionBase, )
 FOR_EACH_INTRINSIC_KIND(extern template class ArrayConstructorValues, )
 FOR_EACH_INTRINSIC_KIND(extern template class ArrayConstructor, )
 
 // Template instantiations to resolve these "extern template" declarations.
 #define INSTANTIATE_EXPRESSION_TEMPLATES \

   FOR_EACH_CATEGORY_TYPE(template class Expr, ) \
   FOR_EACH_INTEGER_KIND(template class Relational, ) \
   FOR_EACH_REAL_KIND(template class Relational, ) \
   FOR_EACH_CHARACTER_KIND(template class Relational, ) \
   template class Relational<SomeType>; \
-  FOR_EACH_TYPE_AND_KIND(template class ExpressionBase, ) \
+  FOR_EACH_INTRINSIC_KIND(template class ExpressionBase, ) \
+  FOR_EACH_CATEGORY_TYPE(template class ExpressionBase, ) \
   FOR_EACH_INTRINSIC_KIND(template class ArrayConstructorValues, ) \
   FOR_EACH_INTRINSIC_KIND(template class ArrayConstructor, )
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_EXPRESSION_H_

flang/include/flang/Evaluate/type.h

   PREFIX<SomeComplex> SUFFIX; \
   PREFIX<SomeCharacter> SUFFIX; \
   PREFIX<SomeLogical> SUFFIX; \
   PREFIX<SomeDerived> SUFFIX; \
   PREFIX<SomeType> SUFFIX;
-#define FOR_EACH_TYPE_AND_KIND(PREFIX, SUFFIX) \
-  FOR_EACH_INTRINSIC_KIND(PREFIX, SUFFIX) \
-  FOR_EACH_CATEGORY_TYPE(PREFIX, SUFFIX)
+
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_TYPE_H_

flang/lib/Evaluate/fold-implementation.h

         }
       },
       std::move(expr.u));
 }
 
-FOR_EACH_TYPE_AND_KIND(extern template class ExpressionBase, )
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_FOLD_IMPLEMENTATION_H_

flang/lib/Semantics/expression.cpp

         cosubsOk = false;
       }
     }
     if (cosubsOk && !reversed.empty()) {
       int numCosubscripts{static_cast<int>(cosubscripts.size())};
-      const Symbol &symbol{reversed.front()};
+      const Symbol &symbol{*reversed.front()};
       if (numCosubscripts != symbol.Corank()) {
         Say("'%s' has corank %d, but coindexed reference has %d cosubscripts"_err_en_US,
             symbol.name(), symbol.Corank(), numCosubscripts);
       }
     }

flang/lib/Semantics/resolve-names.cpp

     if (auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
       if (*attr != object->cudaDataAttr().value_or(*attr)) {
         Say(source,
             "'%s' already has another CUDA data attribute ('%s')"_err_en_US,
             symbol.name(),
-            common::EnumToString(*object->cudaDataAttr()).substr());
+            std::string{common::EnumToString(*object->cudaDataAttr())}.c_str());
       } else {
         object->set_cudaDataAttr(attr);
       }
     } else {
       Say(source,

     if (details.derivedType()) {
       generic.set(Symbol::Flag::Function);
     }
     return;
   }
-  const Symbol &firstSpecific{specifics.front()};
+  const Symbol &firstSpecific{*specifics.front()};
   bool isFunction{firstSpecific.test(Symbol::Flag::Function)};
   bool isBoth{false};
-  for (const Symbol &specific : specifics) {
+  for (const SymbolRef &ref : specifics) {
+    const Symbol &specific{*ref};
     if (isFunction != specific.test(Symbol::Flag::Function)) { // C1514
       auto &msg{Say(generic.name(),
           "Generic interface '%s' has both a function and a subroutine"_warn_en_US)};
       if (isFunction) {
         msg.Attach(firstSpecific.name(), "Function declaration"_en_US);

flang/lib/Semantics/semantics.cpp

       os << symbol.name().ToString() << ": " << sourceInfo->first.file.path()
          << ", " << sourceInfo->first.line << ", " << sourceInfo->first.column
          << "-" << sourceInfo->second.column << "\n";
     } else if (symbol.has<semantics::UseDetails>()) {
       os << symbol.name().ToString() << ": "
-         << symbol.GetUltimate().owner().symbol()->name().ToString() << "\n";
+         << DEREF(symbol.GetUltimate().owner().symbol()).name().ToString()
+         << "\n";
     }
   }
 }
 
 void DoDumpSymbols(llvm::raw_ostream &os, const Scope &scope, int indent) {

flang/unittests/Runtime/Time.cpp

 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#ifndef __clang__ // 16.0.3 lacks <charconv>
+
 #include "gtest/gtest.h"
 #include "flang/Runtime/time-intrinsic.h"
 #include <algorithm>
 #include <cctype>
 #include <charconv>

     auto minutes = number % 100;
     EXPECT_LE(hours, 23);
     EXPECT_LE(minutes, 59);
   }
 }
+
+#endif // __clang__