[flang] Change "unsupported" messages in the runtime to "not yet implemented"

[PeteSteinfeld]

Summary

If a programmer is able to compile and link a program that contains types that
are not yet supported by the runtime, it must be because they're not yet
implemented.

This change will make it easier to find unimplemented code in tests.

flang/runtime/tools.h

case 4:
       return FUNC<TypeCategory::Integer, 4>{}(std::forward<A>(x)...);
     case 8:
       return FUNC<TypeCategory::Integer, 8>{}(std::forward<A>(x)...);
 #ifdef __SIZEOF_INT128__
     case 16:
       return FUNC<TypeCategory::Integer, 16>{}(std::forward<A>(x)...);
 #endif
     default:
-      terminator.Crash("unsupported INTEGER(KIND=%d)", kind);
+      terminator.Crash("not yet implemented: INTEGER(KIND=%d)", kind);
     }
   case TypeCategory::Real:
     switch (kind) {
 #if 0 // TODO: REAL(2 & 3)
     case 2:
       return FUNC<TypeCategory::Real, 2>{}(std::forward<A>(x)...);
     case 3:
       return FUNC<TypeCategory::Real, 3>{}(std::forward<A>(x)...);
 #endif
     case 4:
       return FUNC<TypeCategory::Real, 4>{}(std::forward<A>(x)...);
     case 8:
       return FUNC<TypeCategory::Real, 8>{}(std::forward<A>(x)...);
 #if LONG_DOUBLE == 80
     case 10:
       return FUNC<TypeCategory::Real, 10>{}(std::forward<A>(x)...);
 #elif LONG_DOUBLE == 128
     case 16:
       return FUNC<TypeCategory::Real, 16>{}(std::forward<A>(x)...);
 #endif
     default:
-      terminator.Crash("unsupported REAL(KIND=%d)", kind);
+      terminator.Crash("not yet implemented: REAL(KIND=%d)", kind);
     }
   case TypeCategory::Complex:
     switch (kind) {
 #if 0 // TODO: COMPLEX(2 & 3)
     case 2:
       return FUNC<TypeCategory::Complex, 2>{}(std::forward<A>(x)...);
     case 3:
       return FUNC<TypeCategory::Complex, 3>{}(std::forward<A>(x)...);
 #endif
     case 4:
       return FUNC<TypeCategory::Complex, 4>{}(std::forward<A>(x)...);
     case 8:
       return FUNC<TypeCategory::Complex, 8>{}(std::forward<A>(x)...);
 #if LONG_DOUBLE == 80
     case 10:
       return FUNC<TypeCategory::Complex, 10>{}(std::forward<A>(x)...);
 #elif LONG_DOUBLE == 128
     case 16:
       return FUNC<TypeCategory::Complex, 16>{}(std::forward<A>(x)...);
 #endif
     default:
-      terminator.Crash("unsupported COMPLEX(KIND=%d)", kind);
+      terminator.Crash("not yet implemented: COMPLEX(KIND=%d)", kind);
     }
   case TypeCategory::Character:
     switch (kind) {
     case 1:
       return FUNC<TypeCategory::Character, 1>{}(std::forward<A>(x)...);
     case 2:
       return FUNC<TypeCategory::Character, 2>{}(std::forward<A>(x)...);
     case 4:
       return FUNC<TypeCategory::Character, 4>{}(std::forward<A>(x)...);
     default:
-      terminator.Crash("unsupported CHARACTER(KIND=%d)", kind);
+      terminator.Crash("not yet implemented: CHARACTER(KIND=%d)", kind);
     }
   case TypeCategory::Logical:
     switch (kind) {
     case 1:
       return FUNC<TypeCategory::Logical, 1>{}(std::forward<A>(x)...);
     case 2:
       return FUNC<TypeCategory::Logical, 2>{}(std::forward<A>(x)...);
     case 4:
       return FUNC<TypeCategory::Logical, 4>{}(std::forward<A>(x)...);
     case 8:
       return FUNC<TypeCategory::Logical, 8>{}(std::forward<A>(x)...);
     default:
-      terminator.Crash("unsupported LOGICAL(KIND=%d)", kind);
+      terminator.Crash("not yet implemented: LOGICAL(KIND=%d)", kind);
     }
   default:
-    terminator.Crash("unsupported type category(%d)", static_cast<int>(cat));
+    terminator.Crash(
+        "not yet implemented: type category(%d)", static_cast<int>(cat));
   }
 }
 
 // Maps a runtime INTEGER kind value to the appropriate instantiation of
 // a function object template and calls it with the supplied arguments.
 template <template <int KIND> class FUNC, typename RESULT, typename... A>
 inline RESULT ApplyIntegerKind(int kind, Terminator &terminator, A &&...x) {
   switch (kind) {
   case 1:
     return FUNC<1>{}(std::forward<A>(x)...);
   case 2:
     return FUNC<2>{}(std::forward<A>(x)...);
   case 4:
     return FUNC<4>{}(std::forward<A>(x)...);
   case 8:
     return FUNC<8>{}(std::forward<A>(x)...);
 #ifdef __SIZEOF_INT128__
   case 16:
     return FUNC<16>{}(std::forward<A>(x)...);
 #endif
   default:
-    terminator.Crash("unsupported INTEGER(KIND=%d)", kind);
+    terminator.Crash("not yet implemented: INTEGER(KIND=%d)", kind);
   }
 }
 
 template <template <int KIND> class FUNC, typename RESULT, typename... A>
 inline RESULT ApplyFloatingPointKind(
     int kind, Terminator &terminator, A &&...x) {
   switch (kind) {
 #if 0 // TODO: REAL/COMPLEX (2 & 3)

 #if LONG_DOUBLE == 80
   case 10:
     return FUNC<10>{}(std::forward<A>(x)...);
 #elif LONG_DOUBLE == 128
   case 16:
     return FUNC<16>{}(std::forward<A>(x)...);
 #endif
   default:
-    terminator.Crash("unsupported REAL/COMPLEX(KIND=%d)", kind);
+    terminator.Crash("not yet implemented: REAL/COMPLEX(KIND=%d)", kind);
   }
 }
 
 template <template <int KIND> class FUNC, typename RESULT, typename... A>
 inline RESULT ApplyCharacterKind(int kind, Terminator &terminator, A &&...x) {
   switch (kind) {
   case 1:
     return FUNC<1>{}(std::forward<A>(x)...);
   case 2:
     return FUNC<2>{}(std::forward<A>(x)...);
   case 4:
     return FUNC<4>{}(std::forward<A>(x)...);
   default:
-    terminator.Crash("unsupported CHARACTER(KIND=%d)", kind);
+    terminator.Crash("not yet implemented: CHARACTER(KIND=%d)", kind);
   }
 }
 
 template <template <int KIND> class FUNC, typename RESULT, typename... A>
 inline RESULT ApplyLogicalKind(int kind, Terminator &terminator, A &&...x) {
   switch (kind) {
   case 1:
     return FUNC<1>{}(std::forward<A>(x)...);
   case 2:
     return FUNC<2>{}(std::forward<A>(x)...);
   case 4:
     return FUNC<4>{}(std::forward<A>(x)...);
   case 8:
     return FUNC<8>{}(std::forward<A>(x)...);
   default:
-    terminator.Crash("unsupported LOGICAL(KIND=%d)", kind);
+    terminator.Crash("not yet implemented: LOGICAL(KIND=%d)", kind);
   }
 }
 
 // Calculate result type of (X op Y) for *, //, DOT_PRODUCT, &c.
 std::optional<std::pair<TypeCategory, int>> inline constexpr GetResultType(
     TypeCategory xCat, int xKind, TypeCategory yCat, int yKind) {
   int maxKind{std::max(xKind, yKind)};
   switch (xCat) {