[flang] Distinguish usage and portability warning messages

[klausler]

Summary

Using recently established message severity codes, upgrade
non-fatal messages to usage and portability warnings as
appropriate.

[PeteSteinfeld]

All builds and tests correctly and looks good.

[klausler]

Extend patch to cover newly "upstreamed" code.

[klausler]

Whoops! I updated this review with an updated patch for another review. Here's a good update.

[klausler]

Update test results for folding04.f90.

flang/lib/Evaluate/check-expression.cpp

if (auto symTS{
     if (!converted &&
         symbol.owner().context().IsEnabled(
             common::LanguageFeature::LogicalIntegerAssignment)) {
       converted = DataConstantConversionExtension(context, symTS->type(), x);
       if (converted &&
           symbol.owner().context().ShouldWarn(
               common::LanguageFeature::LogicalIntegerAssignment)) {
         context.messages().Say(
-            "nonstandard usage: initialization of %s with %s"_en_US,
+            "nonstandard usage: initialization of %s with %s"_port_en_US,
             symTS->type().AsFortran(), x.GetType().value().AsFortran());
       }
     }
     if (converted) {
       auto folded{Fold(context, std::move(*converted))};
       if (IsActuallyConstant(folded)) {
         int symRank{GetRank(symTS->shape())};
         if (IsImpliedShape(symbol)) {

flang/lib/Evaluate/common.cpp

 
 using namespace Fortran::parser::literals;
 
 namespace Fortran::evaluate {
 
 void RealFlagWarnings(
     FoldingContext &context, const RealFlags &flags, const char *operation) {
   if (flags.test(RealFlag::Overflow)) {
-    context.messages().Say("overflow on %s"_en_US, operation);
+    context.messages().Say("overflow on %s"_warn_en_US, operation);
   }
   if (flags.test(RealFlag::DivideByZero)) {
     if (std::strcmp(operation, "division") == 0) {
-      context.messages().Say("division by zero"_en_US);
+      context.messages().Say("division by zero"_warn_en_US);
     } else {
-      context.messages().Say("division on %s"_en_US);
+      context.messages().Say("division on %s"_warn_en_US);
     }
   }
   if (flags.test(RealFlag::InvalidArgument)) {
-    context.messages().Say("invalid argument on %s"_en_US, operation);
+    context.messages().Say("invalid argument on %s"_warn_en_US, operation);
   }
   if (flags.test(RealFlag::Underflow)) {
-    context.messages().Say("underflow on %s"_en_US, operation);
+    context.messages().Say("underflow on %s"_warn_en_US, operation);
   }
 }
 
 ConstantSubscript &FoldingContext::StartImpliedDo(
     parser::CharBlock name, ConstantSubscript n) {
   auto pair{impliedDos_.insert(std::make_pair(name, n))};
   CHECK(pair.second);
   return pair.first->second;

flang/lib/Evaluate/fold-complex.cpp

if (name == "acos" || name == "acosh" || name == "asin" || name == "asinh" ||
       name == "atan" || name == "atanh" || name == "cos" || name == "cosh" ||
       name == "exp" || name == "log" || name == "sin" || name == "sinh" ||
       name == "sqrt" || name == "tan" || name == "tanh") {
     if (auto callable{GetHostRuntimeWrapper<T, T>(name)}) {
       return FoldElementalIntrinsic<T, T>(
           context, std::move(funcRef), *callable);
     } else {
       context.messages().Say(
-          "%s(complex(kind=%d)) cannot be folded on host"_en_US, name, KIND);
+          "%s(complex(kind=%d)) cannot be folded on host"_warn_en_US, name,
+          KIND);
     }
   } else if (name == "conjg") {
     return FoldElementalIntrinsic<T, T>(
         context, std::move(funcRef), &Scalar<T>::CONJG);
   } else if (name == "cmplx") {
     if (args.size() > 0 && args[0].has_value()) {
       if (auto *x{UnwrapExpr<Expr<SomeComplex>>(args[0])}) {
         // CMPLX(X [, KIND]) with complex X

flang/lib/Evaluate/fold-implementation.h

return std::visit(
         char buffer[64];
         if (auto value{GetScalarConstantValue<Operand>(kindExpr)}) {
           FoldingContext &ctx{msvcWorkaround.context};
           if constexpr (TO::category == TypeCategory::Integer) {
             if constexpr (FromCat == TypeCategory::Integer) {
               auto converted{Scalar<TO>::ConvertSigned(*value)};
               if (converted.overflow) {
                 ctx.messages().Say(
-                    "INTEGER(%d) to INTEGER(%d) conversion overflowed"_en_US,
+                    "INTEGER(%d) to INTEGER(%d) conversion overflowed"_warn_en_US,
                     Operand::kind, TO::kind);
               }
               return ScalarConstantToExpr(std::move(converted.value));
             } else if constexpr (FromCat == TypeCategory::Real) {
               auto converted{value->template ToInteger<Scalar<TO>>()};
               if (converted.flags.test(RealFlag::InvalidArgument)) {
                 ctx.messages().Say(
-                    "REAL(%d) to INTEGER(%d) conversion: invalid argument"_en_US,
+                    "REAL(%d) to INTEGER(%d) conversion: invalid argument"_warn_en_US,
                     Operand::kind, TO::kind);
               } else if (converted.flags.test(RealFlag::Overflow)) {
                 ctx.messages().Say(
-                    "REAL(%d) to INTEGER(%d) conversion overflowed"_en_US,
+                    "REAL(%d) to INTEGER(%d) conversion overflowed"_warn_en_US,
                     Operand::kind, TO::kind);
               }
               return ScalarConstantToExpr(std::move(converted.value));
             }
           } else if constexpr (TO::category == TypeCategory::Real) {
             if constexpr (FromCat == TypeCategory::Integer) {
               auto converted{Scalar<TO>::FromInteger(*value)};
               if (!converted.flags.empty()) {
Expr<T> FoldOperation(FoldingContext &context, Negate<T> &&x) {
   auto &operand{x.left()};
   if (auto *nn{std::get_if<Negate<T>>(&x.left().u)}) {
     return std::move(nn->left()); // -(-x) -> x
   } else if (auto value{GetScalarConstantValue<T>(operand)}) {
     if constexpr (T::category == TypeCategory::Integer) {
       auto negated{value->Negate()};
       if (negated.overflow) {
         context.messages().Say(
-            "INTEGER(%d) negation overflowed"_en_US, T::kind);
+            "INTEGER(%d) negation overflowed"_warn_en_US, T::kind);
       }
       return Expr<T>{Constant<T>{std::move(negated.value)}};
     } else {
       // REAL & COMPLEX negation: no exceptions possible
       return Expr<T>{Constant<T>{value->Negate()}};
     }
   }
   return Expr<T>{std::move(x)};
Expr<T> FoldOperation(FoldingContext &context, Add<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
   }
   if (auto folded{OperandsAreConstants(x)}) {
     if constexpr (T::category == TypeCategory::Integer) {
       auto sum{folded->first.AddSigned(folded->second)};
       if (sum.overflow) {
         context.messages().Say(
-            "INTEGER(%d) addition overflowed"_en_US, T::kind);
+            "INTEGER(%d) addition overflowed"_warn_en_US, T::kind);
       }
       return Expr<T>{Constant<T>{sum.value}};
     } else {
       auto sum{folded->first.Add(folded->second, context.rounding())};
       RealFlagWarnings(context, sum.flags, "addition");
       if (context.flushSubnormalsToZero()) {
         sum.value = sum.value.FlushSubnormalToZero();
       }
       return Expr<T>{Constant<T>{sum.value}};
     }
   }
   return Expr<T>{std::move(x)};
 }
 
 template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Subtract<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
   }
   if (auto folded{OperandsAreConstants(x)}) {
     if constexpr (T::category == TypeCategory::Integer) {
       auto difference{folded->first.SubtractSigned(folded->second)};
       if (difference.overflow) {
         context.messages().Say(
-            "INTEGER(%d) subtraction overflowed"_en_US, T::kind);
+            "INTEGER(%d) subtraction overflowed"_warn_en_US, T::kind);
       }
       return Expr<T>{Constant<T>{difference.value}};
     } else {
       auto difference{
           folded->first.Subtract(folded->second, context.rounding())};
       RealFlagWarnings(context, difference.flags, "subtraction");
       if (context.flushSubnormalsToZero()) {
         difference.value = difference.value.FlushSubnormalToZero();
Expr<T> FoldOperation(FoldingContext &context, Multiply<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
   }
   if (auto folded{OperandsAreConstants(x)}) {
     if constexpr (T::category == TypeCategory::Integer) {
       auto product{folded->first.MultiplySigned(folded->second)};
       if (product.SignedMultiplicationOverflowed()) {
         context.messages().Say(
-            "INTEGER(%d) multiplication overflowed"_en_US, T::kind);
+            "INTEGER(%d) multiplication overflowed"_warn_en_US, T::kind);
       }
       return Expr<T>{Constant<T>{product.lower}};
     } else {
       auto product{folded->first.Multiply(folded->second, context.rounding())};
       RealFlagWarnings(context, product.flags, "multiplication");
       if (context.flushSubnormalsToZero()) {
         product.value = product.value.FlushSubnormalToZero();
       }

 Expr<T> FoldOperation(FoldingContext &context, Divide<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
   }
   if (auto folded{OperandsAreConstants(x)}) {
     if constexpr (T::category == TypeCategory::Integer) {
       auto quotAndRem{folded->first.DivideSigned(folded->second)};
       if (quotAndRem.divisionByZero) {
-        context.messages().Say("INTEGER(%d) division by zero"_en_US, T::kind);
+        context.messages().Say(
+            "INTEGER(%d) division by zero"_warn_en_US, T::kind);
         return Expr<T>{std::move(x)};
       }
       if (quotAndRem.overflow) {
         context.messages().Say(
-            "INTEGER(%d) division overflowed"_en_US, T::kind);
+            "INTEGER(%d) division overflowed"_warn_en_US, T::kind);
       }
       return Expr<T>{Constant<T>{quotAndRem.quotient}};
     } else {
       auto quotient{folded->first.Divide(folded->second, context.rounding())};
       RealFlagWarnings(context, quotient.flags, "division");
       if (context.flushSubnormalsToZero()) {
         quotient.value = quotient.value.FlushSubnormalToZero();
       }
       return Expr<T>{Constant<T>{quotient.value}};
     }
   }
   return Expr<T>{std::move(x)};
 }
 
 template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Power<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
   }
   if (auto folded{OperandsAreConstants(x)}) {
     if constexpr (T::category == TypeCategory::Integer) {
       auto power{folded->first.Power(folded->second)};
       if (power.divisionByZero) {
         context.messages().Say(
-            "INTEGER(%d) zero to negative power"_en_US, T::kind);
+            "INTEGER(%d) zero to negative power"_warn_en_US, T::kind);
       } else if (power.overflow) {
-        context.messages().Say("INTEGER(%d) power overflowed"_en_US, T::kind);
+        context.messages().Say(
+            "INTEGER(%d) power overflowed"_warn_en_US, T::kind);
       } else if (power.zeroToZero) {
         context.messages().Say(
-            "INTEGER(%d) 0**0 is not defined"_en_US, T::kind);
+            "INTEGER(%d) 0**0 is not defined"_warn_en_US, T::kind);
       }
       return Expr<T>{Constant<T>{power.power}};
     } else {
       if (auto callable{GetHostRuntimeWrapper<T, T, T>("pow")}) {
         return Expr<T>{
             Constant<T>{(*callable)(context, folded->first, folded->second)}};
       } else {
         context.messages().Say(
-            "Power for %s cannot be folded on host"_en_US, T{}.AsFortran());
+            "Power for %s cannot be folded on host"_warn_en_US,
+            T{}.AsFortran());
       }
     }
   }
   return Expr<T>{std::move(x)};
 }
 
 template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, RealToIntPower<T> &&x) {
std::visit(
           From original{x};
           result = ConvertToType<Result>(std::move(x));
           const auto *constant{UnwrapExpr<Constant<Result>>(*result)};
           CHECK(constant);
           Scalar<Result> real{constant->GetScalarValue().value()};
           From converted{From::ConvertUnsigned(real.RawBits()).value};
           if (original != converted) { // C1601
             context.messages().Say(
-                "Nonzero bits truncated from BOZ literal constant in REAL intrinsic"_en_US);
+                "Nonzero bits truncated from BOZ literal constant in REAL intrinsic"_warn_en_US);
           }
         } else if constexpr (IsNumericCategoryExpr<From>()) {
           result = Fold(context, ConvertToType<Result>(std::move(x)));
         } else {
           common::die("ToReal: bad argument expression");
         }
       },
       std::move(expr.u));

flang/lib/Evaluate/fold-integer.cpp

Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
   CHECK(intrinsic);
   std::string name{intrinsic->name};
   if (name == "abs") { // incl. babs, iiabs, jiaabs, & kiabs
     return FoldElementalIntrinsic<T, T>(context, std::move(funcRef),
         ScalarFunc<T, T>([&context](const Scalar<T> &i) -> Scalar<T> {
           typename Scalar<T>::ValueWithOverflow j{i.ABS()};
           if (j.overflow) {
             context.messages().Say(
-                "abs(integer(kind=%d)) folding overflowed"_en_US, KIND);
+                "abs(integer(kind=%d)) folding overflowed"_warn_en_US, KIND);
           }
           return j.value;
         }));
   } else if (name == "bit_size") {
     return Expr<T>{Scalar<T>::bits};
   } else if (name == "ceiling" || name == "floor" || name == "nint") {
     if (const auto *cx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
       // NINT rounds ties away from zero, not to even
       common::RoundingMode mode{name == "ceiling" ? common::RoundingMode::Up
               : name == "floor"                   ? common::RoundingMode::Down
                                 : common::RoundingMode::TiesAwayFromZero};
       return std::visit(
           [&](const auto &kx) {
             using TR = ResultType<decltype(kx)>;
             return FoldElementalIntrinsic<T, TR>(context, std::move(funcRef),
                 ScalarFunc<T, TR>([&](const Scalar<TR> &x) {
                   auto y{x.template ToInteger<Scalar<T>>(mode)};
                   if (y.flags.test(RealFlag::Overflow)) {
                     context.messages().Say(
-                        "%s intrinsic folding overflow"_en_US, name);
+                        "%s intrinsic folding overflow"_warn_en_US, name);
                   }
                   return y.value;
                 }));
           },
           cx->u);
     }
   } else if (name == "count") {
     return FoldCount<T>(context, std::move(funcRef));
if (name == "abs") { // incl. babs, iiabs, jiaabs, & kiabs
     return Expr<T>{Scalar<T>::HUGE()};
   } else if (name == "iachar" || name == "ichar") {
     auto *someChar{UnwrapExpr<Expr<SomeCharacter>>(args[0])};
     CHECK(someChar);
     if (auto len{ToInt64(someChar->LEN())}) {
       if (len.value() != 1) {
         // Do not die, this was not checked before
         context.messages().Say(
-            "Character in intrinsic function %s must have length one"_en_US,
+            "Character in intrinsic function %s must have length one"_warn_en_US,
             name);
       } else {
         return std::visit(
             [&funcRef, &context](const auto &str) -> Expr<T> {
               using Char = typename std::decay_t<decltype(str)>::Result;
               return FoldElementalIntrinsic<T, Char>(context,
                   std::move(funcRef),
                   ScalarFunc<T, Char>([](const Scalar<Char> &c) {
return FoldMaxvalMinval<T>(
         context, std::move(funcRef), RelationalOperator::LT, T::Scalar::HUGE());
   } else if (name == "mod") {
     return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef),
         ScalarFuncWithContext<T, T, T>(
             [](FoldingContext &context, const Scalar<T> &x,
                 const Scalar<T> &y) -> Scalar<T> {
               auto quotRem{x.DivideSigned(y)};
               if (quotRem.divisionByZero) {
-                context.messages().Say("mod() by zero"_en_US);
+                context.messages().Say("mod() by zero"_warn_en_US);
               } else if (quotRem.overflow) {
-                context.messages().Say("mod() folding overflowed"_en_US);
+                context.messages().Say("mod() folding overflowed"_warn_en_US);
               }
               return quotRem.remainder;
             }));
   } else if (name == "modulo") {
     return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef),
         ScalarFuncWithContext<T, T, T>(
             [](FoldingContext &context, const Scalar<T> &x,
                 const Scalar<T> &y) -> Scalar<T> {
               auto result{x.MODULO(y)};
               if (result.overflow) {
-                context.messages().Say("modulo() folding overflowed"_en_US);
+                context.messages().Say(
+                    "modulo() folding overflowed"_warn_en_US);
               }
               return result.value;
             }));
   } else if (name == "not") {
     return FoldElementalIntrinsic<T, T>(
         context, std::move(funcRef), &Scalar<T>::NOT);
   } else if (name == "precision") {
     if (const auto *cx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
return FoldElementalIntrinsic<T, T, Int4>(context, std::move(funcRef),
         }));
   } else if (name == "sign") {
     return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef),
         ScalarFunc<T, T, T>(
             [&context](const Scalar<T> &j, const Scalar<T> &k) -> Scalar<T> {
               typename Scalar<T>::ValueWithOverflow result{j.SIGN(k)};
               if (result.overflow) {
                 context.messages().Say(
-                    "sign(integer(kind=%d)) folding overflowed"_en_US, KIND);
+                    "sign(integer(kind=%d)) folding overflowed"_warn_en_US,
+                    KIND);
               }
               return result.value;
             }));
   } else if (name == "size") {
     if (auto shape{GetContextFreeShape(context, args[0])}) {
       if (auto &dimArg{args[1]}) { // DIM= is present, get one extent
         if (auto dim{GetInt64Arg(args[1])}) {
           int rank{GetRank(*shape)};
           if (*dim >= 1 && *dim <= rank) {
             const Symbol *symbol{UnwrapWholeSymbolDataRef(args[0])};
             if (symbol && IsAssumedSizeArray(*symbol) && *dim == rank) {
               context.messages().Say(
                   "size(array,dim=%jd) of last dimension is not available for rank-%d assumed-size array dummy argument"_err_en_US,
                   *dim, rank);
               return MakeInvalidIntrinsic<T>(std::move(funcRef));
             } else if (auto &extent{shape->at(*dim - 1)}) {
               return Fold(context, ConvertToType<T>(std::move(*extent)));
             }
           } else {
             context.messages().Say(
-                "size(array,dim=%jd) dimension is out of range for rank-%d array"_en_US,
+                "size(array,dim=%jd) dimension is out of range for rank-%d array"_warn_en_US,
                 *dim, rank);
           }
         }
       } else if (auto extents{common::AllElementsPresent(std::move(*shape))}) {
         // DIM= is absent; compute PRODUCT(SHAPE())
         ExtentExpr product{1};
         for (auto &&extent : std::move(*extents)) {
           product = std::move(product) * std::move(extent);

flang/lib/Evaluate/fold-real.cpp

if (name == "acos" || name == "acosh" || name == "asin" || name == "asinh" ||
       name == "log_gamma" || name == "sin" || name == "sinh" || name == "tan" ||
       name == "tanh") {
     CHECK(args.size() == 1);
     if (auto callable{GetHostRuntimeWrapper<T, T>(name)}) {
       return FoldElementalIntrinsic<T, T>(
           context, std::move(funcRef), *callable);
     } else {
       context.messages().Say(
-          "%s(real(kind=%d)) cannot be folded on host"_en_US, name, KIND);
+          "%s(real(kind=%d)) cannot be folded on host"_warn_en_US, name, KIND);
     }
   } else if (name == "amax0" || name == "amin0" || name == "amin1" ||
       name == "amax1" || name == "dmin1" || name == "dmax1") {
     return RewriteSpecificMINorMAX(context, std::move(funcRef));
   } else if (name == "atan" || name == "atan2" || name == "mod") {
     std::string localName{name == "atan" ? "atan2" : name};
     CHECK(args.size() == 2);
     if (auto callable{GetHostRuntimeWrapper<T, T, T>(localName)}) {
       return FoldElementalIntrinsic<T, T, T>(
           context, std::move(funcRef), *callable);
     } else {
       context.messages().Say(
-          "%s(real(kind=%d), real(kind%d)) cannot be folded on host"_en_US,
+          "%s(real(kind=%d), real(kind%d)) cannot be folded on host"_warn_en_US,
           name, KIND, KIND);
     }
   } else if (name == "bessel_jn" || name == "bessel_yn") {
     if (args.size() == 2) { // elemental
       // runtime functions use int arg
       using Int4 = Type<TypeCategory::Integer, 4>;
       if (auto callable{GetHostRuntimeWrapper<T, Int4, T>(name)}) {
         return FoldElementalIntrinsic<T, Int4, T>(
             context, std::move(funcRef), *callable);
       } else {
         context.messages().Say(
-            "%s(integer(kind=4), real(kind=%d)) cannot be folded on host"_en_US,
+            "%s(integer(kind=4), real(kind=%d)) cannot be folded on host"_warn_en_US,
             name, KIND);
       }
     }
   } else if (name == "abs") { // incl. zabs & cdabs
     // Argument can be complex or real
     if (auto *x{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
       return FoldElementalIntrinsic<T, T>(
           context, std::move(funcRef), &Scalar<T>::ABS);
if (name == "acos" || name == "acosh" || name == "asin" || name == "asinh" ||
     common::RoundingMode mode{name == "aint"
             ? common::RoundingMode::ToZero
             : common::RoundingMode::TiesAwayFromZero};
     return FoldElementalIntrinsic<T, T>(context, std::move(funcRef),
         ScalarFunc<T, T>([&name, &context, mode](
                              const Scalar<T> &x) -> Scalar<T> {
           ValueWithRealFlags<Scalar<T>> y{x.ToWholeNumber(mode)};
           if (y.flags.test(RealFlag::Overflow)) {
-            context.messages().Say("%s intrinsic folding overflow"_en_US, name);
+            context.messages().Say(
+                "%s intrinsic folding overflow"_warn_en_US, name);
           }
           return y.value;
         }));
   } else if (name == "dprod") {
     if (auto scalars{GetScalarConstantArguments<T, T>(context, args)}) {
       return Fold(context,
           Expr<T>{Multiply<T>{
               Expr<T>{std::get<0>(*scalars)}, Expr<T>{std::get<1>(*scalars)}}});

 // MSVC chokes on the keyword "template" here in a call to a
 // member function template.
 #ifndef _MSC_VER
                                                            template
 #endif
                                                            SCALE(y)};
                       if (result.flags.test(RealFlag::Overflow)) {
                         context.messages().Say(
-                            "SCALE intrinsic folding overflow"_en_US);
+                            "SCALE intrinsic folding overflow"_warn_en_US);
                       }
                       return result.value;
                     }));
           },
           byExpr->u);
     }
   } else if (name == "sign") {
     return FoldElementalIntrinsic<T, T, T>(

flang/lib/Evaluate/fold-reduction.h

auto accumulator{[&](Element &element, const ConstantSubscripts &at) {
       } else { // Real & Complex
         auto prod{element.Multiply(array->At(at))};
         overflow |= prod.flags.test(RealFlag::Overflow);
         element = prod.value;
       }
     }};
     if (overflow) {
       context.messages().Say(
-          "PRODUCT() of %s data overflowed"_en_US, T::AsFortran());
+          "PRODUCT() of %s data overflowed"_warn_en_US, T::AsFortran());
     } else {
       return Expr<T>{DoReduction<T>(*array, dim, identity, accumulator)};
     }
   }
   return Expr<T>{std::move(ref)};
 }
 
 // SUM
auto accumulator{[&](Element &element, const ConstantSubscripts &at) {
         // correction = (sum - element) - next; algebraically zero
         correction =
             sum.value.Subtract(element).value.Subtract(next.value).value;
         element = sum.value;
       }
     }};
     if (overflow) {
       context.messages().Say(
-          "SUM() of %s data overflowed"_en_US, T::AsFortran());
+          "SUM() of %s data overflowed"_warn_en_US, T::AsFortran());
     } else {
       return Expr<T>{DoReduction<T>(*array, dim, identity, accumulator)};
     }
   }
   return Expr<T>{std::move(ref)};
 }
 
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_FOLD_REDUCTION_H_

flang/lib/Evaluate/host.cpp

case common::RoundingMode::Up:
     break;
   case common::RoundingMode::Down:
     fesetround(FE_DOWNWARD);
     break;
   case common::RoundingMode::TiesAwayFromZero:
     fesetround(FE_TONEAREST);
     context.messages().Say(
         "TiesAwayFromZero rounding mode is not available when folding constants"
-        " with host runtime; using TiesToEven instead"_en_US);
+        " with host runtime; using TiesToEven instead"_warn_en_US);
     break;
   }
   flags_.clear();
   errno = 0;
 }
 void HostFloatingPointEnvironment::CheckAndRestoreFloatingPointEnvironment(
     FoldingContext &context) {
   int errnoCapture{errno};

flang/lib/Evaluate/intrinsics.cpp

if (const char *genericName{specIter->second->generic}) {
              ++genIter) {
           if (auto specificCall{
                   matchOrBufferMessages(*genIter->second, specificBuffer)}) {
             // Force the call result type to the specific intrinsic result type
             DynamicType newType{GetReturnType(*specIter->second, defaults_)};
             context.messages().Say(
                 "argument types do not match specific intrinsic '%s' "
                 "requirements; using '%s' generic instead and converting the "
-                "result to %s if needed"_en_US,
+                "result to %s if needed"_port_en_US,
                 call.name, genericName, newType.AsFortran());
             specificCall->specificIntrinsic.name = call.name;
             specificCall->specificIntrinsic.characteristics.value()
                 .functionResult.value()
                 .SetType(newType);
             return specificCall;
           }
         }

flang/lib/Evaluate/variable.cpp

result = std::visit(
           }
           return std::nullopt;
         },
         strings->u);
   }
   if (!result) { // error cases
     if (*lbi < 1) {
       context.messages().Say(
-          "Lower bound (%jd) on substring is less than one"_en_US,
+          "Lower bound (%jd) on substring is less than one"_warn_en_US,
           static_cast<std::intmax_t>(*lbi));
       *lbi = 1;
       lower_ = AsExpr(Constant<SubscriptInteger>{1});
     }
     if (length && *ubi > *length) {
       context.messages().Say(
-          "Upper bound (%jd) on substring is greater than character length (%jd)"_en_US,
+          "Upper bound (%jd) on substring is greater than character length (%jd)"_warn_en_US,
           static_cast<std::intmax_t>(*ubi),
           static_cast<std::intmax_t>(*length));
       *ubi = *length;
       upper_ = AsExpr(Constant<SubscriptInteger>{*ubi});
     }
   }
   return result;
 }

flang/lib/Parser/basic-parsers.h

if (UserState * ustate{state.userState()}) {
       if (!ustate->features().IsEnabled(LF)) {
         return std::nullopt;
       }
     }
     auto at{state.GetLocation()};
     auto result{parser_.Parse(state)};
     if (result) {
       state.Nonstandard(CharBlock{at, std::max(state.GetLocation(), at + 1)},
-          LF, "nonstandard usage"_en_US);
+          LF, "nonstandard usage"_port_en_US);
     }
     return result;
   }
 
 private:
   const PA parser_;
 };
 
std::optional<resultType> Parse(ParseState &state) const {
     if (UserState * ustate{state.userState()}) {
       if (!ustate->features().IsEnabled(LF)) {
         return std::nullopt;
       }
     }
     auto at{state.GetLocation()};
     auto result{parser_.Parse(state)};
     if (result) {
-      state.Nonstandard(
-          CharBlock{at, state.GetLocation()}, LF, "deprecated usage"_en_US);
+      state.Nonstandard(CharBlock{at, state.GetLocation()}, LF,
+          "deprecated usage"_port_en_US);
     }
     return result;
   }
 
 private:
   const PA parser_;
 };
 

flang/lib/Parser/preprocessor.cpp

void Preprocessor::Directive(const TokenSequence &dir, Prescanner &prescanner) {
   } else if (dirName == "undef") {
     if (nameToken.empty()) {
       prescanner.Say(
           dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
           "# missing or invalid name"_err_en_US);
     } else {
       if (dir.IsAnythingLeft(++j)) {
         prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
-            "#undef: excess tokens at end of directive"_en_US);
+            "#undef: excess tokens at end of directive"_port_en_US);
       } else {
         definitions_.erase(nameToken);
       }
     }
   } else if (dirName == "ifdef" || dirName == "ifndef") {
     bool doThen{false};
     if (nameToken.empty()) {
       prescanner.Say(
           dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
           "#%s: missing name"_err_en_US, dirName);
     } else {
       if (dir.IsAnythingLeft(++j)) {
         prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
-            "#%s: excess tokens at end of directive"_en_US, dirName);
+            "#%s: excess tokens at end of directive"_port_en_US, dirName);
       }
       doThen = IsNameDefined(nameToken) == (dirName == "ifdef");
     }
     if (doThen) {
       ifStack_.push(CanDeadElseAppear::Yes);
     } else {
       SkipDisabledConditionalCode(dirName, IsElseActive::Yes, prescanner,
           dir.GetTokenProvenance(dirOffset));
     }
   } else if (dirName == "if") {
     if (IsIfPredicateTrue(dir, j, tokens - j, prescanner)) {
       ifStack_.push(CanDeadElseAppear::Yes);
     } else {
       SkipDisabledConditionalCode(dirName, IsElseActive::Yes, prescanner,
           dir.GetTokenProvenanceRange(dirOffset));
     }
   } else if (dirName == "else") {
     if (dir.IsAnythingLeft(j)) {
       prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
-          "#else: excess tokens at end of directive"_en_US);
+          "#else: excess tokens at end of directive"_port_en_US);
     } else if (ifStack_.empty()) {
       prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#else: not nested within #if, #ifdef, or #ifndef"_err_en_US);
     } else if (ifStack_.top() != CanDeadElseAppear::Yes) {
       prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#else: already appeared within this #if, #ifdef, or #ifndef"_err_en_US);
     } else {
       ifStack_.pop();
if (dirName == "line") {
     } else {
       ifStack_.pop();
       SkipDisabledConditionalCode("elif", IsElseActive::No, prescanner,
           dir.GetTokenProvenanceRange(dirOffset));
     }
   } else if (dirName == "endif") {
     if (dir.IsAnythingLeft(j)) {
       prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
-          "#endif: excess tokens at end of directive"_en_US);
+          "#endif: excess tokens at end of directive"_port_en_US);
     } else if (ifStack_.empty()) {
       prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#endif: no #if, #ifdef, or #ifndef"_err_en_US);
     } else {
       ifStack_.pop();
     }
   } else if (dirName == "error") {
     prescanner.Say(
         dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
         "%s"_err_en_US, dir.ToString());
-  } else if (dirName == "warning" || dirName == "comment" ||
-      dirName == "note") {
+  } else if (dirName == "warning") {
+    prescanner.Say(
+        dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
+        "%s"_warn_en_US, dir.ToString());
+  } else if (dirName == "comment" || dirName == "note") {
     prescanner.Say(
         dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
         "%s"_en_US, dir.ToString());
   } else if (dirName == "include") {
     if (j == tokens) {
       prescanner.Say(
           dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
           "#include: missing name of file to include"_err_en_US);
       return;
     }
     std::string include;
     std::optional<std::string> prependPath;
     if (dir.TokenAt(j).ToString() == "<") { // #include <foo>
       std::size_t k{j + 1};
       if (k >= tokens) {
         prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
             "#include: file name missing"_err_en_US);
         return;
       }
       while (k < tokens && dir.TokenAt(k) != ">") {
         ++k;
       }
       if (k >= tokens) {
         prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
-            "#include: expected '>' at end of included file"_en_US);
+            "#include: expected '>' at end of included file"_port_en_US);
       }
       TokenSequence braced{dir, j + 1, k - j - 1};
       include = ReplaceMacros(braced, prescanner).ToString();
       j = k;
     } else if ((include = dir.TokenAt(j).ToString()).substr(0, 1) == "\"" &&
         include.substr(include.size() - 1, 1) == "\"") { // #include "foo"
       include = include.substr(1, include.size() - 2);
       // #include "foo" starts search in directory of file containing
if (dirName == "line") {
     if (include.empty()) {
       prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#include: empty include file name"_err_en_US);
       return;
     }
     j = dir.SkipBlanks(j + 1);
     if (j < tokens && dir.TokenAt(j).ToString() != "!") {
       prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
-          "#include: extra stuff ignored after file name"_en_US);
+          "#include: extra stuff ignored after file name"_port_en_US);
     }
     std::string buf;
     llvm::raw_string_ostream error{buf};
     const SourceFile *included{
         allSources_.Open(include, error, std::move(prependPath))};
     if (!included) {
       prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#include: %s"_err_en_US, error.str());

flang/lib/Parser/prescan.cpp

if (std::optional<TokenSequence> preprocessed{
     case LineClassification::Kind::IncludeLine:
       FortranInclude(ppd + ppl.payloadOffset);
       break;
     case LineClassification::Kind::ConditionalCompilationDirective:
     case LineClassification::Kind::IncludeDirective:
     case LineClassification::Kind::DefinitionDirective:
     case LineClassification::Kind::PreprocessorDirective:
       Say(preprocessed->GetProvenanceRange(),
-          "Preprocessed line resembles a preprocessor directive"_en_US);
+          "Preprocessed line resembles a preprocessor directive"_warn_en_US);
       preprocessed->ToLowerCase()
           .CheckBadFortranCharacters(messages_)
           .CheckBadParentheses(messages_)
           .Emit(cooked_);
       break;
     case LineClassification::Kind::CompilerDirective:
       if (preprocessed->HasRedundantBlanks()) {
         preprocessed->RemoveRedundantBlanks();
if (*at_ != ' ' &&
       if (!bad && !IsDecimalDigit(*at_)) {
         bad = at_;
       }
     }
     ++column_;
   }
   if (bad && !preprocessor_.IsNameDefined(token.CurrentOpenToken())) {
     Say(GetProvenance(bad),
-        "Character in fixed-form label field must be a digit"_en_US);
+        "Character in fixed-form label field must be a digit"_warn_en_US);
     token.clear();
     at_ = start;
     return;
   }
   if (outCol == 1) { // empty label field
     // Emit a space so that, if the line is rescanned after preprocessing,
     // a leading 'C' or 'D' won't be left-justified and then accidentally
     // misinterpreted as a comment card.
     EmitChar(token, ' ');
     ++outCol;
   }
   token.CloseToken();
   SkipToNextSignificantCharacter();
   if (IsDecimalDigit(*at_)) {
     Say(GetProvenance(at_),
-        "Label digit is not in fixed-form label field"_en_US);
+        "Label digit is not in fixed-form label field"_port_en_US);
   }
 }
 
 // 6.3.3.5: A program unit END statement, or any other statement whose
 // initial line resembles an END statement, shall not be continued in
 // fixed form source.
 void Prescanner::EnforceStupidEndStatementRules(const TokenSequence &tokens) {
   CharBlock cBlock{tokens.ToCharBlock()};
bool Prescanner::NextToken(TokenSequence &tokens) {
   CHECK(at_ >= start_ && at_ < limit_);
   if (InFixedFormSource()) {
     SkipSpaces();
   } else {
     if (*at_ == '/' && IsCComment(at_)) {
       // Recognize and skip over classic C style /*comments*/ when
       // outside a character literal.
       if (features_.ShouldWarn(LanguageFeature::ClassicCComments)) {
-        Say(GetProvenance(at_), "nonstandard usage: C-style comment"_en_US);
+        Say(GetProvenance(at_),
+            "nonstandard usage: C-style comment"_port_en_US);
       }
       SkipCComments();
     }
     if (*at_ == ' ' || *at_ == '\t') {
       // Compress free-form white space into a single space character.
       const auto theSpace{at_};
       char previous{at_ <= start_ ? ' ' : at_[-1]};
       NextChar();
void Prescanner::Hollerith(
     TokenSequence &tokens, int count, const char *start) {
   inCharLiteral_ = true;
   CHECK(*at_ == 'h' || *at_ == 'H');
   EmitChar(tokens, 'H');
   while (count-- > 0) {
     if (PadOutCharacterLiteral(tokens)) {
     } else if (*at_ == '\n') {
       Say(GetProvenanceRange(start, at_),
-          "Possible truncated Hollerith literal"_en_US);
+          "Possible truncated Hollerith literal"_warn_en_US);
       break;
     } else {
       NextChar();
       // Each multi-byte character encoding counts as a single character.
       // No escape sequences are recognized.
       // Hollerith is always emitted to the cooked character
       // stream in UTF-8.
       DecodedCharacter decoded{DecodeCharacter(
if (*p != quote) {
     return;
   }
   p = SkipWhiteSpace(p + 1);
   if (*p != '\n' && *p != '!') {
     const char *garbage{p};
     for (; *p != '\n' && *p != '!'; ++p) {
     }
     Say(GetProvenanceRange(garbage, p),
-        "excess characters after path name"_en_US);
+        "excess characters after path name"_warn_en_US);
   }
   std::string buf;
   llvm::raw_string_ostream error{buf};
   Provenance provenance{GetProvenance(nextLine_)};
   std::optional<std::string> prependPath;
   if (const SourceFile * currentFile{allSources_.GetSourceFile(provenance)}) {
     prependPath = DirectoryName(currentFile->path());
   }
const char *Prescanner::FixedFormContinuationLine(bool mightNeedSpace) {
   } else {
     // Normal case: not in a compiler directive.
     if (col1 == '&' &&
         features_.IsEnabled(
             LanguageFeature::FixedFormContinuationWithColumn1Ampersand)) {
       // Extension: '&' as continuation marker
       if (features_.ShouldWarn(
               LanguageFeature::FixedFormContinuationWithColumn1Ampersand)) {
-        Say(GetProvenance(nextLine_), "nonstandard usage"_en_US);
+        Say(GetProvenance(nextLine_), "nonstandard usage"_port_en_US);
       }
       return nextLine_ + 1;
     }
     if (col1 == '\t' && nextLine_[1] >= '1' && nextLine_[1] <= '9') {
       tabInCurrentLine_ = true;
       return nextLine_ + 2; // VAX extension
     }
     if (col1 == ' ' && nextLine_[1] == ' ' && nextLine_[2] == ' ' &&
bool Prescanner::FreeFormContinuation() {
   if (ampersand) {
     p = SkipWhiteSpace(p + 1);
   }
   if (*p != '\n') {
     if (inCharLiteral_) {
       return false;
     } else if (*p != '!' &&
         features_.ShouldWarn(LanguageFeature::CruftAfterAmpersand)) {
-      Say(GetProvenance(p), "missing ! before comment after &"_en_US);
+      Say(GetProvenance(p), "missing ! before comment after &"_warn_en_US);
     }
   }
   do {
     if (const char *cont{FreeFormContinuationLine(ampersand)}) {
       BeginSourceLine(cont);
       NextLine();
       return true;
     }

flang/lib/Parser/token-parsers.h

 };
 constexpr Space space;
 
 // Skips a space that in free form requires a warning if it precedes a
 // character that could begin an identifier or keyword.  Always succeeds.
 inline void MissingSpace(ParseState &state) {
   if (!state.inFixedForm()) {
     state.Nonstandard(
-        LanguageFeature::OptionalFreeFormSpace, "missing space"_en_US);
+        LanguageFeature::OptionalFreeFormSpace, "missing space"_port_en_US);
   }
 }
 
 struct SpaceCheck {
   using resultType = Success;
   constexpr SpaceCheck() {}
   static std::optional<Success> Parse(ParseState &state) {
     if (std::optional<const char *> p{state.PeekAtNextChar()}) {
static std::optional<resultType> Parse(ParseState &state) {
 
     space.Parse(state);
     const char *start{state.GetLocation()};
     std::optional<const char *> at{nextCh.Parse(state)};
     if (!at) {
       return std::nullopt;
     }
     if (**at == 'x' &&
-        !state.IsNonstandardOk(
-            LanguageFeature::BOZExtensions, "nonstandard BOZ literal"_en_US)) {
+        !state.IsNonstandardOk(LanguageFeature::BOZExtensions,
+            "nonstandard BOZ literal"_port_en_US)) {
       return std::nullopt;
     }
     if (baseChar(**at)) {
       at = nextCh.Parse(state);
       if (!at) {
         return std::nullopt;
       }
     }
while (true) {
       }
       content += ToLowerCaseLetter(**at);
     }
 
     if (!base) {
       // extension: base allowed to appear as suffix, too
       if (!(at = nextCh.Parse(state)) || !baseChar(**at) ||
           !state.IsNonstandardOk(LanguageFeature::BOZExtensions,
-              "nonstandard BOZ literal"_en_US)) {
+              "nonstandard BOZ literal"_port_en_US)) {
         return std::nullopt;
       }
       spaceCheck.Parse(state);
     }
 
     if (content.empty()) {
       state.Say(start, "no digit in BOZ literal"_err_en_US);
       return std::nullopt;
while (std::optional<const char *> at{state.PeekAtNextChar()}) {
         } else if (remain >= freeBytes &&
             std::memcmp(*at, free, freeBytes) == 0) {
           state.set_inFixedForm(false).UncheckedAdvance(freeBytes);
         } else {
           break;
         }
       } else if (**at == ';' &&
           state.IsNonstandardOk(
-              LanguageFeature::EmptyStatement, "empty statement"_en_US)) {
+              LanguageFeature::EmptyStatement, "empty statement"_port_en_US)) {
         state.UncheckedAdvance();
       } else {
         break;
       }
     }
     return {Success{}};
   }
 };

flang/lib/Semantics/check-call.cpp

if (dummyType.type().category() == TypeCategory::Character &&
       dummyType.type().kind() == actualType.type().kind() &&
       GetRank(actualType.shape()) == 0) {
     if (dummyType.LEN() && actualType.LEN()) {
       auto dummyLength{ToInt64(Fold(context, common::Clone(*dummyType.LEN())))};
       auto actualLength{
           ToInt64(Fold(context, common::Clone(*actualType.LEN())))};
       if (dummyLength && actualLength && *actualLength < *dummyLength) {
         messages.Say(
-            "Actual length '%jd' is less than expected length '%jd'"_en_US,
+            "Actual length '%jd' is less than expected length '%jd'"_warn_en_US,
             *actualLength, *dummyLength);
         auto converted{ConvertToType(dummyType.type(), std::move(actual))};
         CHECK(converted);
         actual = std::move(*converted);
         actualType.set_LEN(SubscriptIntExpr{*dummyLength});
       }
     }
   }
if (dummyType.type().category() == TypeCategory::Integer &&
       GetRank(dummyType.shape()) == 0 && GetRank(actualType.shape()) == 0 &&
       !evaluate::IsVariable(actual)) {
     auto converted{
         evaluate::ConvertToType(dummyType.type(), std::move(actual))};
     CHECK(converted);
     actual = std::move(*converted);
     if (dummyType.type().kind() < actualType.type().kind()) {
       messages.Say(
-          "Actual argument scalar expression of type INTEGER(%d) was converted to smaller dummy argument type INTEGER(%d)"_en_US,
+          "Actual argument scalar expression of type INTEGER(%d) was converted to smaller dummy argument type INTEGER(%d)"_port_en_US,
           actualType.type().kind(), dummyType.type().kind());
     }
     actualType = dummyType;
   }
 }
 
 static bool DefersSameTypeParameters(
     const DerivedTypeSpec &actual, const DerivedTypeSpec &dummy) {
if (actualIsUnlimited != dummyIsUnlimited) {
       if (typesCompatible) {
         messages.Say(
             "If a POINTER or ALLOCATABLE dummy or actual argument is unlimited polymorphic, both must be so"_err_en_US);
       }
     } else if (dummyIsPolymorphic != actualIsPolymorphic) {
       if (dummy.intent == common::Intent::In && typesCompatible) {
         // extension: allow with warning, rule is only relevant for definables
         messages.Say(
-            "If a POINTER or ALLOCATABLE dummy or actual argument is polymorphic, both should be so"_en_US);
+            "If a POINTER or ALLOCATABLE dummy or actual argument is polymorphic, both should be so"_port_en_US);
       } else {
         messages.Say(
             "If a POINTER or ALLOCATABLE dummy or actual argument is polymorphic, both must be so"_err_en_US);
       }
     } else if (!actualIsUnlimited && typesCompatible) {
       if (!actualType.type().IsTkCompatibleWith(dummy.type.type())) {
         if (dummy.intent == common::Intent::In) {
           // extension: allow with warning, rule is only relevant for definables
           messages.Say(
-              "POINTER or ALLOCATABLE dummy and actual arguments should have the same declared type and kind"_en_US);
+              "POINTER or ALLOCATABLE dummy and actual arguments should have the same declared type and kind"_port_en_US);
         } else {
           messages.Say(
               "POINTER or ALLOCATABLE dummy and actual arguments must have the same declared type and kind"_err_en_US);
         }
       }
       if (const auto *derived{
               evaluate::GetDerivedTypeSpec(actualType.type())}) {
         if (!DefersSameTypeParameters(
if (auto argChars{characteristics::DummyArgument::FromActual(
               } else if (proc.IsPure()) {
                 messages.Say(
                     "Actual procedure argument for %s of a PURE procedure must have an explicit interface"_err_en_US,
                     dummyName);
               } else {
                 messages.Say(
                     "Actual procedure argument has an implicit interface "
                     "which is not known to be compatible with %s which has an "
-                    "explicit interface"_en_US,
+                    "explicit interface"_warn_en_US,
                     dummyName);
               }
             }
           } else { // 15.5.2.9(2,3)
             if (interface.IsSubroutine() && argInterface.IsFunction()) {
               messages.Say(
                   "Actual argument associated with procedure %s is a function but must be a subroutine"_err_en_US,
                   dummyName);
if (!buffer.empty()) {
       return; // don't pile on
     }
   }
   if (explicitInterface) {
     auto buffer{
         CheckExplicitInterface(proc, actuals, context, scope, intrinsic)};
     if (treatingExternalAsImplicit && !buffer.empty()) {
       if (auto *msg{messages.Say(
-              "Warning: if the procedure's interface were explicit, this reference would be in error:"_en_US)}) {
+              "If the procedure's interface were explicit, this reference would be in error:"_warn_en_US)}) {
         buffer.AttachTo(*msg);
       }
     }
     if (auto *msgs{messages.messages()}) {
       msgs->Annex(std::move(buffer));
     }
   }
 }
 } // namespace Fortran::semantics

flang/lib/Semantics/check-case.cpp

void AddCase(const parser::CaseConstruct::Case &c) {
     const auto &selector{std::get<parser::CaseSelector>(caseStmt.t)};
     std::visit(
         common::visitors{
             [&](const std::list<parser::CaseValueRange> &ranges) {
               for (const auto &range : ranges) {
                 auto pair{ComputeBounds(range)};
                 if (pair.first && pair.second && *pair.first > *pair.second) {
                   context_.Say(stmt.source,
-                      "CASE has lower bound greater than upper bound"_en_US);
+                      "CASE has lower bound greater than upper bound"_warn_en_US);
                 } else {
                   if constexpr (T::category == TypeCategory::Logical) { // C1148
                     if ((pair.first || pair.second) &&
                         (!pair.first || !pair.second ||
                             *pair.first != *pair.second)) {
                       context_.Say(stmt.source,
                           "CASE range is not allowed for LOGICAL"_err_en_US);
                     }

flang/lib/Semantics/check-data.cpp

if (const char *whyNot{IsAutomatic(symbol) ? "Automatic variable"
                 : nullptr}) {
       context_.Say(source_,
           "%s '%s' must not be initialized in a DATA statement"_err_en_US,
           whyNot, symbol.name());
       return false;
     }
     if (IsProcedurePointer(symbol)) {
       context_.Say(source_,
-          "Procedure pointer '%s' in a DATA statement is not standard"_en_US,
+          "Procedure pointer '%s' in a DATA statement is not standard"_port_en_US,
           symbol.name());
     }
     if (IsInBlankCommon(symbol)) {
       context_.Say(source_,
-          "Blank COMMON object '%s' in a DATA statement is not standard"_en_US,
+          "Blank COMMON object '%s' in a DATA statement is not standard"_port_en_US,
           symbol.name());
     }
     return true;
   }
   bool operator()(const evaluate::Component &component) {
     hasComponent_ = true;
     const Symbol &lastSymbol{component.GetLastSymbol()};
     if (isPointerAllowed_) {

flang/lib/Semantics/check-declarations.cpp

if (IsAutomatic(symbol)) {
       messages_.Say(
           "An automatic variable or component must not be initialized"_err_en_US);
     } else if (IsDummy(symbol)) {
       messages_.Say("A dummy argument must not be initialized"_err_en_US);
     } else if (IsFunctionResult(symbol)) {
       messages_.Say("A function result must not be initialized"_err_en_US);
     } else if (IsInBlankCommon(symbol)) {
       messages_.Say(
-          "A variable in blank COMMON should not be initialized"_en_US);
+          "A variable in blank COMMON should not be initialized"_port_en_US);
     }
   }
   if (symbol.owner().kind() == Scope::Kind::BlockData) {
     if (IsAllocatable(symbol)) {
       messages_.Say(
           "An ALLOCATABLE variable may not appear in a BLOCK DATA subprogram"_err_en_US);
     } else if (IsInitialized(symbol) && !FindCommonBlockContaining(symbol)) {
       messages_.Say(
void CheckHelper::WarnMissingFinal(const Symbol &symbol) {
   int rank{object->shape().Rank()};
   const Symbol *initialDerivedSym{derivedSym};
   while (const auto *derivedDetails{
       derivedSym ? derivedSym->detailsIf<DerivedTypeDetails>() : nullptr}) {
     if (!derivedDetails->finals().empty() &&
         !derivedDetails->GetFinalForRank(rank)) {
       if (auto *msg{derivedSym == initialDerivedSym
                   ? messages_.Say(symbol.name(),
-                        "'%s' of derived type '%s' does not have a FINAL subroutine for its rank (%d)"_en_US,
+                        "'%s' of derived type '%s' does not have a FINAL subroutine for its rank (%d)"_warn_en_US,
                         symbol.name(), derivedSym->name(), rank)
                   : messages_.Say(symbol.name(),
-                        "'%s' of derived type '%s' extended from '%s' does not have a FINAL subroutine for its rank (%d)"_en_US,
+                        "'%s' of derived type '%s' extended from '%s' does not have a FINAL subroutine for its rank (%d)"_warn_en_US,
                         symbol.name(), initialDerivedSym->name(),
                         derivedSym->name(), rank)}) {
         msg->Attach(derivedSym->name(),
             "Declaration of derived type '%s'"_en_US, derivedSym->name());
       }
       return;
     }
     derived = derivedSym->GetParentTypeSpec();

flang/lib/Semantics/check-do-forall.cpp

private:
   }
 
   void CheckDoControl(const parser::CharBlock &sourceLocation, bool isReal) {
     const bool warn{context_.warnOnNonstandardUsage() ||
         context_.ShouldWarn(common::LanguageFeature::RealDoControls)};
     if (isReal && !warn) {
       // No messages for the default case
     } else if (isReal && warn) {
-      context_.Say(sourceLocation, "DO controls should be INTEGER"_en_US);
+      context_.Say(sourceLocation, "DO controls should be INTEGER"_port_en_US);
     } else {
       SayBadDoControl(sourceLocation);
     }
   }
 
   void CheckDoVariable(const parser::ScalarName &scalarName) {
     const parser::CharBlock &sourceLocation{scalarName.thing.source};
     if (const Symbol * symbol{scalarName.thing.symbol}) {
void CheckDoNormal(const parser::DoConstruct &doConstruct) {
     const Bounds &bounds{GetBounds(doConstruct)};
     CheckDoVariable(bounds.name);
     CheckDoExpression(bounds.lower);
     CheckDoExpression(bounds.upper);
     if (bounds.step) {
       CheckDoExpression(*bounds.step);
       if (IsZero(*bounds.step)) {
         context_.Say(bounds.step->thing.value().source,
-            "DO step expression should not be zero"_en_US);
+            "DO step expression should not be zero"_warn_en_US);
       }
     }
   }
 
   void CheckDoConcurrent(const parser::DoConstruct &doConstruct) {
     auto &doStmt{
         std::get<parser::Statement<parser::NonLabelDoStmt>>(doConstruct.t)};
     currentStatementSourcePosition_ = doStmt.source;
void CheckDefaultNoneImpliesExplicitLocality(
       const std::list<parser::LocalitySpec> &localitySpecs,
       const parser::Block &block) const {
     bool hasDefaultNone{false};
     for (auto &ls : localitySpecs) {
       if (std::holds_alternative<parser::LocalitySpec::DefaultNone>(ls.u)) {
         if (hasDefaultNone) {
           // C1127, you can only have one DEFAULT(NONE)
           context_.Say(currentStatementSourcePosition_,
-              "Only one DEFAULT(NONE) may appear"_en_US);
+              "Only one DEFAULT(NONE) may appear"_port_en_US);
           break;
         }
         hasDefaultNone = true;
       }
     }
     if (hasDefaultNone) {
       DoConcurrentVariableEnforce doConcurrentVariableEnforce{
           context_, currentStatementSourcePosition_};

 #endif
                 }
               },
               [](const auto &) {},
           },
           assignment.u);
       for (const Symbol &index : indexVars) {
         if (symbols.count(index) == 0) {
-          context_.Say(
-              "Warning: FORALL index variable '%s' not used on left-hand side"
-              " of assignment"_en_US,
+          context_.Say("FORALL index variable '%s' not used on left-hand side"
+                       " of assignment"_warn_en_US,
               index.name());
         }
       }
     }
   }
 
   // For messages where the DO loop must be DO CONCURRENT, make that explicit.
   const char *LoopKindName() const {

flang/lib/Semantics/check-io.cpp

std::visit(
                     expr->Rank() > 0) &&
                 context_.IsEnabled(
                     common::LanguageFeature::NonCharacterFormat)) {
               // Legacy extension: using non-character variables, typically
               // DATA-initialized with Hollerith, as format expressions.
               if (context_.ShouldWarn(
                       common::LanguageFeature::NonCharacterFormat)) {
                 context_.Say(format.source,
-                    "Non-character format expression is not standard"_en_US);
+                    "Non-character format expression is not standard"_port_en_US);
               }
             } else if (!type ||
                 type->kind() !=
                     context_.defaultKinds().GetDefaultKind(type->category())) {
               context_.Say(format.source,
                   "Format expression must be default character or default scalar integer"_err_en_US);
               return;
             }
static std::unordered_map<IoSpecKind, const std::set<std::string>> specValues{
       {IoSpecKind::Convert, {"BIG_ENDIAN", "LITTLE_ENDIAN", "NATIVE"}},
       {IoSpecKind::Dispose, {"DELETE", "KEEP"}},
   };
   auto upper{parser::ToUpperCaseLetters(value)};
   if (specValues.at(specKind).count(upper) == 0) {
     if (specKind == IoSpecKind::Access && upper == "APPEND") {
       if (context_.languageFeatures().ShouldWarn(
               common::LanguageFeature::OpenAccessAppend)) {
-        context_.Say(source, "ACCESS='%s' interpreted as POSITION='%s'"_en_US,
-            value, upper);
+        context_.Say(source,
+            "ACCESS='%s' interpreted as POSITION='%s'"_port_en_US, value,
+            upper);
       }
     } else {
       context_.Say(source, "Invalid %s value '%s'"_err_en_US,
           parser::ToUpperCaseLetters(common::EnumToString(specKind)), value);
     }
   }
 }
 

flang/lib/Semantics/check-omp-structure.cpp

std::visit(
                 c.u);
           },
           [&](const auto &c) {},
       },
       c.u);
   if (!eligibleTarget) {
     context_.Say(parser::FindSourceLocation(c),
         "If %s directive is nested inside TARGET region, the behaviour "
-        "is unspecified"_en_US,
+        "is unspecified"_port_en_US,
         parser::ToUpperCaseLetters(
             getDirectiveName(ineligibleTargetDir).str()));
   }
 }
 
 std::int64_t OmpStructureChecker::GetOrdCollapseLevel(
     const parser::OpenMPLoopConstruct &x) {
   const auto &beginLoopDir{std::get<parser::OmpBeginLoopDirective>(x.t)};
std::visit(
                     context_.Say(name->source,
                         "The entity with PARAMETER attribute cannot be in a %s "
                         "directive"_err_en_US,
                         ContextDirectiveAsFortran());
                   else if (GetContext().directive ==
                       llvm::omp::Directive::OMPD_declare_target)
                     context_.Say(name->source,
                         "The entity with PARAMETER attribute is used in a %s "
-                        "directive"_en_US,
+                        "directive"_warn_en_US,
                         ContextDirectiveAsFortran());
                 } else if (FindCommonBlockContaining(*name->symbol)) {
                   context_.Say(name->source,
                       "A variable in a %s directive cannot be an element of a "
                       "common block"_err_en_US,
                       ContextDirectiveAsFortran());
                 } else if (!IsSave(*name->symbol) &&
                     declScope.kind() != Scope::Kind::MainProgram &&

flang/lib/Semantics/check-return.cpp

void ReturnStmtChecker::Leave(const parser::ReturnStmt &returnStmt) {
   const auto &scope{context_.FindScope(context_.location().value())};
   if (const auto *subprogramScope{FindContainingSubprogram(scope)}) {
     if (returnStmt.v &&
         (subprogramScope->kind() == Scope::Kind::MainProgram ||
             IsFunction(*subprogramScope->GetSymbol()))) {
       context_.Say(
           "RETURN with expression is only allowed in SUBROUTINE subprogram"_err_en_US);
     } else if (context_.ShouldWarn(common::LanguageFeature::ProgramReturn)) {
-      context_.Say("RETURN should not appear in a main program"_en_US);
+      context_.Say("RETURN should not appear in a main program"_port_en_US);
     }
   }
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/data-to-inits.cpp

if (std::optional<std::string> chValue{
     }
   }
   SemanticsContext &context{exprAnalyzer_.context()};
   if (context.IsEnabled(common::LanguageFeature::LogicalIntegerAssignment)) {
     if (MaybeExpr converted{evaluate::DataConstantConversionExtension(
             exprAnalyzer_.GetFoldingContext(), type, expr)}) {
       if (context.ShouldWarn(
               common::LanguageFeature::LogicalIntegerAssignment)) {
-        context.Say("nonstandard usage: initialization of %s with %s"_en_US,
+        context.Say(
+            "nonstandard usage: initialization of %s with %s"_port_en_US,
             type.AsFortran(), expr.GetType().value().AsFortran());
       }
       return {std::make_pair(std::move(*converted), false)};
     }
   }
   return std::nullopt;
 }
 
if (expr->Rank() > 0) {
       exprAnalyzer_.Say(
           "DATA statement value initializes '%s' with an array"_err_en_US,
           DescribeElement());
     } else if (auto converted{ConvertElement(*expr, *designatorType)}) {
       // value non-pointer initialization
       if (IsBOZLiteral(*expr) &&
           designatorType->category() != TypeCategory::Integer) { // 8.6.7(11)
         exprAnalyzer_.Say(
-            "BOZ literal should appear in a DATA statement only as a value for an integer object, but '%s' is '%s'"_en_US,
+            "BOZ literal should appear in a DATA statement only as a value for an integer object, but '%s' is '%s'"_port_en_US,
             DescribeElement(), designatorType->AsFortran());
       } else if (converted->second) {
         exprAnalyzer_.context().Say(
-            "DATA statement value initializes '%s' of type '%s' with CHARACTER"_en_US,
+            "DATA statement value initializes '%s' of type '%s' with CHARACTER"_port_en_US,
             DescribeElement(), designatorType->AsFortran());
       }
       auto folded{evaluate::Fold(context, std::move(converted->first))};
       switch (GetImage().Add(
           offsetSymbol.offset(), offsetSymbol.size(), folded, context)) {
       case evaluate::InitialImage::Ok:
         return true;
       case evaluate::InitialImage::NotAConstant:

flang/lib/Semantics/expression.cpp

if (T::kind >= kind) {
         if (T::kind > kind) {
           if (!isDefaultKind ||
               !analyzer.context().IsEnabled(LanguageFeature::BigIntLiterals)) {
             return std::nullopt;
           } else if (analyzer.context().ShouldWarn(
                          LanguageFeature::BigIntLiterals)) {
             analyzer.Say(digits,
                 "Integer literal is too large for default INTEGER(KIND=%d); "
-                "assuming INTEGER(KIND=%d)"_en_US,
+                "assuming INTEGER(KIND=%d)"_port_en_US,
                 kind, T::kind);
           }
         }
         return Expr<SomeType>{
             Expr<SomeInteger>{Expr<T>{Constant<T>{std::move(value.value)}}}};
       }
     }
     return std::nullopt;
MaybeExpr ExpressionAnalyzer::Analyze(const parser::RealLiteralConstant &x) {
   }
   if (letterKind) {
     defaultKind = *letterKind;
   }
   // C716 requires 'E' as an exponent, but this is more useful
   auto kind{AnalyzeKindParam(x.kind, defaultKind)};
   if (letterKind && kind != *letterKind && expoLetter != 'e') {
     Say("Explicit kind parameter on real constant disagrees with "
-        "exponent letter '%c'"_en_US,
+        "exponent letter '%c'"_port_en_US,
         expoLetter);
   }
   auto result{common::SearchTypes(
       RealTypeVisitor{kind, x.real.source, GetFoldingContext()})};
   if (!result) { // C717
     Say("Unsupported REAL(KIND=%d)"_err_en_US, kind);
   }
   return AsMaybeExpr(std::move(result));
if (!x) {
     return;
   }
   if (!type_) {
     if (auto *boz{std::get_if<BOZLiteralConstant>(&x->u)}) {
       // Treat an array constructor of BOZ as if default integer.
       if (exprAnalyzer_.context().ShouldWarn(
               common::LanguageFeature::BOZAsDefaultInteger)) {
         exprAnalyzer_.Say(
-            "BOZ literal in array constructor without explicit type is assumed to be default INTEGER"_en_US);
+            "BOZ literal in array constructor without explicit type is assumed to be default INTEGER"_port_en_US);
       }
       x = AsGenericExpr(ConvertToKind<TypeCategory::Integer>(
           exprAnalyzer_.GetDefaultKind(TypeCategory::Integer),
           std::move(*boz)));
     }
   }
   std::optional<DynamicType> dyType{x->GetType()};
   if (!dyType) {
     if (auto *boz{std::get_if<BOZLiteralConstant>(&x->u)}) {
       if (!type_) {
         // Treat an array constructor of BOZ as if default integer.
         if (exprAnalyzer_.context().ShouldWarn(
                 common::LanguageFeature::BOZAsDefaultInteger)) {
           exprAnalyzer_.Say(
-              "BOZ literal in array constructor without explicit type is assumed to be default INTEGER"_en_US);
+              "BOZ literal in array constructor without explicit type is assumed to be default INTEGER"_port_en_US);
         }
         x = AsGenericExpr(ConvertToKind<TypeCategory::Integer>(
             exprAnalyzer_.GetDefaultKind(TypeCategory::Integer),
             std::move(*boz)));
         dyType = x.value().GetType();
       } else if (auto cast{ConvertToType(*type_, std::move(*x))}) {
         x = std::move(cast);
         dyType = *type_;
if (type_->IsTkCompatibleWith(xType) && xType.IsTkCompatibleWith(*type_)) {
       values_.Push(std::move(*x));
       if (auto thisLen{ToInt64(xType.LEN())}) {
         if (constantLength_) {
           if (exprAnalyzer_.context().warnOnNonstandardUsage() &&
               *thisLen != *constantLength_) {
             if (!(messageDisplayedSet_ & 1)) {
               exprAnalyzer_.Say(
                   "Character literal in array constructor without explicit "
-                  "type has different length than earlier elements"_en_US);
+                  "type has different length than earlier elements"_port_en_US);
               messageDisplayedSet_ |= 1;
             }
           }
           if (*thisLen > *constantLength_) {
             // Language extension: use the longest literal to determine the
             // length of the array constructor's character elements, not the
             // first, when there is no explicit type.
             *constantLength_ = *thisLen;
if (const auto &kw{std::get<std::optional<parser::Keyword>>(component.t)}) {
         auto iter{
             std::find(components.begin(), components.end(), *parentComponent)};
         if (iter != components.end()) {
           symbol = parentComponent;
           nextAnonymous = ++iter;
           if (context().ShouldWarn(LanguageFeature::AnonymousParents)) {
             Say(source,
                 "Whole parent component '%s' in structure "
-                "constructor should not be anonymous"_en_US,
+                "constructor should not be anonymous"_port_en_US,
                 symbol->name());
           }
         }
       }
       while (!symbol && nextAnonymous != components.end()) {
         const Symbol &next{*nextAnonymous};
         ++nextAnonymous;
         if (!next.test(Symbol::Flag::ParentComp)) {
void ExpressionAnalyzer::CheckBadExplicitType(
   if (intrinsic.GetUltimate().GetType()) {
     const auto &procedure{call.specificIntrinsic.characteristics.value()};
     if (const auto &result{procedure.functionResult}) {
       if (const auto *typeAndShape{result->GetTypeAndShape()}) {
         if (auto declared{
                 typeAndShape->Characterize(intrinsic, GetFoldingContext())}) {
           if (!declared->type().IsTkCompatibleWith(typeAndShape->type())) {
             if (auto *msg{Say(
-                    "The result type '%s' of the intrinsic function '%s' is not the explicit declared type '%s'"_en_US,
+                    "The result type '%s' of the intrinsic function '%s' is not the explicit declared type '%s'"_warn_en_US,
                     typeAndShape->AsFortran(), intrinsic.name(),
                     declared->AsFortran())}) {
               msg->Attach(intrinsic.name(),
                   "Ignored declaration of intrinsic function '%s'"_en_US,
                   intrinsic.name());
             }
           }
         }
bool ArgumentAnalyzer::OkLogicalIntegerAssignment(
     TypeCategory lhs, TypeCategory rhs) {
   if (!context_.context().languageFeatures().IsEnabled(
           common::LanguageFeature::LogicalIntegerAssignment)) {
     return false;
   }
   std::optional<parser::MessageFixedText> msg;
   if (lhs == TypeCategory::Integer && rhs == TypeCategory::Logical) {
     // allow assignment to LOGICAL from INTEGER as a legacy extension
-    msg = "nonstandard usage: assignment of LOGICAL to INTEGER"_en_US;
+    msg = "nonstandard usage: assignment of LOGICAL to INTEGER"_port_en_US;
   } else if (lhs == TypeCategory::Logical && rhs == TypeCategory::Integer) {
     // ... and assignment to LOGICAL from INTEGER
-    msg = "nonstandard usage: assignment of INTEGER to LOGICAL"_en_US;
+    msg = "nonstandard usage: assignment of INTEGER to LOGICAL"_port_en_US;
   } else {
     return false;
   }
   if (context_.context().languageFeatures().ShouldWarn(
           common::LanguageFeature::LogicalIntegerAssignment)) {
     context_.Say(std::move(*msg));
   }
   return true;

flang/lib/Semantics/mod-file.cpp

if (!silent) {
             parser::MessageFixedText{str.c_str(), str.size(), msg.severity()},
             path);
       }
     }
     return nullptr;
   }
   CHECK(sourceFile);
   if (!VerifyHeader(sourceFile->content())) {
-    Say(name, ancestorName, "File has invalid checksum: %s"_en_US,
+    Say(name, ancestorName, "File has invalid checksum: %s"_warn_en_US,
         sourceFile->path());
     return nullptr;
   }
   llvm::raw_null_ostream NullStream;
   parsing.Parse(NullStream);
   auto &parseTree{parsing.parseTree()};
   if (!parsing.messages().empty() || !parsing.consumedWholeFile() ||
       !parseTree) {

flang/lib/Semantics/resolve-labels.cpp

void CheckBranchesIntoDoBody(const SourceStmtList &branches,
   for (const auto &branch : branches) {
     const auto &label{branch.parserLabel};
     auto branchTarget{GetLabel(labels, label)};
     if (HasScope(branchTarget.proxyForScope)) {
       const auto &fromPosition{branch.parserCharBlock};
       const auto &toPosition{branchTarget.parserCharBlock};
       for (const auto &body : loopBodies) {
         if (!InBody(fromPosition, body) && InBody(toPosition, body)) {
-          context.Say(fromPosition, "branch into loop body from outside"_en_US)
+          context
+              .Say(
+                  fromPosition, "branch into loop body from outside"_warn_en_US)
               .Attach(body.first, "the loop branched into"_en_US);
         }
       }
     }
   }
 }
 
 void CheckDoNesting(const IndexList &loopBodies, SemanticsContext &context) {
if (!HasScope(doTarget.proxyForScope)) {
                        TargetStatementEnum::CompatibleDo)) ||
         (doTarget.isExecutableConstructEndStmt &&
             ParentScope(scopes, doTarget.proxyForScope) == scope)) {
       if (context.warnOnNonstandardUsage() ||
           context.ShouldWarn(
               common::LanguageFeature::OldLabelDoEndStatements)) {
         context
             .Say(position,
-                "A DO loop should terminate with an END DO or CONTINUE"_en_US)
+                "A DO loop should terminate with an END DO or CONTINUE"_port_en_US)
             .Attach(doTarget.parserCharBlock,
                 "DO loop currently ends at statement:"_en_US);
       }
     } else if (!InInclusiveScope(scopes, scope, doTarget.proxyForScope)) {
       context.Say(position, "Label '%u' is not in DO loop scope"_err_en_US,
           SayLabel(label));
     } else if (!doTarget.labeledStmtClassificationSet.test(
                    TargetStatementEnum::Do)) {
if (HasScope(branchTarget.proxyForScope)) {
             .Say(branchTarget.parserCharBlock,
                 "Label '%u' is not a branch target"_err_en_US, SayLabel(label))
             .Attach(stmt.parserCharBlock, "Control flow use of '%u'"_en_US,
                 SayLabel(label));
       } else if (!branchTarget.labeledStmtClassificationSet.test(
                      TargetStatementEnum::Branch)) { // warning
         context
             .Say(branchTarget.parserCharBlock,
-                "Label '%u' is not a branch target"_en_US, SayLabel(label))
+                "Label '%u' is not a branch target"_warn_en_US, SayLabel(label))
             .Attach(stmt.parserCharBlock, "Control flow use of '%u'"_en_US,
                 SayLabel(label));
       }
     }
   }
 }
 
 void CheckBranchConstraints(const SourceStmtList &branches,
if (HasScope(target.proxyForScope) &&
         !target.labeledStmtClassificationSet.test(
             TargetStatementEnum::Branch) &&
         !target.labeledStmtClassificationSet.test(
             TargetStatementEnum::Format)) {
       context
           .Say(target.parserCharBlock,
               target.labeledStmtClassificationSet.test(
                   TargetStatementEnum::CompatibleBranch)
-                  ? "Label '%u' is not a branch target or FORMAT"_en_US
+                  ? "Label '%u' is not a branch target or FORMAT"_warn_en_US
                   : "Label '%u' is not a branch target or FORMAT"_err_en_US,
               SayLabel(label))
           .Attach(stmt.parserCharBlock, "ASSIGN statement use of '%u'"_en_US,
               SayLabel(label));
     }
   }
 }
 

flang/lib/Semantics/resolve-names-utils.cpp

if (sym1.attrs().test(Attr::PROTECTED) &&
     msg = "Equivalence set cannot contain '%s'"
           " with PROTECTED attribute and '%s' without"_err_en_US;
   } else if ((isDefaultNum1 && isDefaultNum2) || (isChar1 && isChar2)) {
     // ok & standard conforming
   } else if (!(isAnyNum1 || isChar1) &&
       !(isAnyNum2 || isChar2)) { // C8110 - C8113
     if (AreTkCompatibleTypes(type1, type2)) {
       if (context_.ShouldWarn(LanguageFeature::EquivalenceSameNonSequence)) {
-        msg = "nonstandard: Equivalence set contains '%s' and '%s' with same "
-              "type "
-              "that is neither numeric nor character sequence type"_en_US;
+        msg =
+            "nonstandard: Equivalence set contains '%s' and '%s' with same "
+            "type that is neither numeric nor character sequence type"_port_en_US;
       }
     } else {
       msg = "Equivalence set cannot contain '%s' and '%s' with distinct types "
             "that are not both numeric or character sequence types"_err_en_US;
     }
   } else if (isAnyNum1) {
     if (isChar2) {
       if (context_.ShouldWarn(
               LanguageFeature::EquivalenceNumericWithCharacter)) {
         msg = "nonstandard: Equivalence set contains '%s' that is numeric "
-              "sequence "
-              "type and '%s' that is character"_en_US;
+              "sequence type and '%s' that is character"_port_en_US;
       }
     } else if (isAnyNum2 &&
         context_.ShouldWarn(LanguageFeature::EquivalenceNonDefaultNumeric)) {
       if (isDefaultNum1) {
         msg =
             "nonstandard: Equivalence set contains '%s' that is a default "
-            "numeric "
-            "sequence type and '%s' that is numeric with non-default kind"_en_US;
+            "numeric sequence type and '%s' that is numeric with non-default kind"_port_en_US;
       } else if (!isDefaultNum2) {
         msg = "nonstandard: Equivalence set contains '%s' and '%s' that are "
-              "numeric "
-              "sequence types with non-default kinds"_en_US;
+              "numeric sequence types with non-default kinds"_port_en_US;
       }
     }
   }
   if (msg) {
     context_.Say(source, std::move(*msg), sym1.name(), sym2.name());
     return false;
   }
   return true;

flang/lib/Semantics/resolve-names.cpp

void AttrsVisitor::SetBindNameOn(Symbol &symbol) {
   }
   std::optional<std::string> label{
       evaluate::GetScalarConstantValue<evaluate::Ascii>(bindName_)};
   // 18.9.2(2): discard leading and trailing blanks, ignore if all blank
   if (label) {
     auto first{label->find_first_not_of(" ")};
     if (first == std::string::npos) {
       // Empty NAME= means no binding at all (18.10.2p2)
-      Say(currStmtSource().value(), "Blank binding label ignored"_en_US);
+      Say(currStmtSource().value(), "Blank binding label ignored"_warn_en_US);
       return;
     }
     auto last{label->find_last_not_of(" ")};
     label = label->substr(first, last - first + 1);
   } else {
     label = parser::ToLowerCaseLetters(symbol.name().ToString());
   }
   symbol.SetBindName(std::move(*label));
bool AttrsVisitor::Pre(const parser::Pass &x) {
   }
   return false;
 }
 
 // C730, C743, C755, C778, C1543 say no attribute or prefix repetitions
 bool AttrsVisitor::IsDuplicateAttr(Attr attrName) {
   if (attrs_->test(attrName)) {
     Say(currStmtSource().value(),
-        "Attribute '%s' cannot be used more than once"_en_US,
+        "Attribute '%s' cannot be used more than once"_warn_en_US,
         AttrToString(attrName));
     return true;
   }
   return false;
 }
 
 // See if attrName violates a constraint cause by a conflict.  attr1 and attr2
 // name attributes that cannot be used on the same declaration
bool ScopeHandler::ImplicitlyTypeForwardRef(Symbol &symbol) {
   }
   if (!ConvertToObjectEntity(symbol)) {
     return false;
   }
   // TODO: check no INTENT(OUT)?
   if (context().languageFeatures().ShouldWarn(
           common::LanguageFeature::ForwardRefDummyImplicitNone)) {
     Say(symbol.name(),
-        "Dummy argument '%s' was used without being explicitly typed"_en_US,
+        "Dummy argument '%s' was used without being explicitly typed"_warn_en_US,
         symbol.name());
   }
   symbol.set(Symbol::Flag::Implicit);
   symbol.SetType(*type);
   return true;
 }
 
 // Ensure that the symbol for an intrinsic procedure is marked with
funcInfoStack_.back().resultSymbol =
         &MakeSymbol(*funcResultName, std::move(funcResultDetails));
     details.set_result(*funcInfoStack_.back().resultSymbol);
   }
   // C1560.
   if (info.resultName && info.resultName->source == name.source) {
     Say(info.resultName->source,
         "The function name should not appear in RESULT, references to '%s' "
         "inside the function will be considered as references to the "
-        "result only"_en_US,
+        "result only"_warn_en_US,
         name.source);
     // RESULT name was ignored above, the only side effect from doing so will be
     // the inability to make recursive calls. The related parser::Name is still
     // resolved to the created function result symbol because every parser::Name
     // should be resolved to avoid internal errors.
     Resolve(*info.resultName, info.resultSymbol);
   }
   name.symbol = currScope().symbol(); // must not be function result symbol
for (const auto &name : x.v) {
     } else if (symbol.attrs().test(Attr::EXTERNAL)) { // C840
       Say(symbol.name(),
           "Symbol '%s' cannot have both EXTERNAL and INTRINSIC attributes"_err_en_US,
           symbol.name());
     } else if (symbol.GetType()) {
       // These warnings are worded so that they should make sense in either
       // order.
       Say(symbol.name(),
-          "Explicit type declaration ignored for intrinsic function '%s'"_en_US,
+          "Explicit type declaration ignored for intrinsic function '%s'"_warn_en_US,
           symbol.name())
           .Attach(name.source,
               "INTRINSIC statement for explicitly-typed '%s'"_en_US,
               name.source);
     }
   }
   return false;
 }
if (!currScope().parent().IsModule()) {
     Say("PRIVATE is only allowed in a derived type that is"
         " in a module"_err_en_US); // C766
   } else if (derivedTypeInfo_.sawContains) {
     derivedTypeInfo_.privateBindings = true;
   } else if (!derivedTypeInfo_.privateComps) {
     derivedTypeInfo_.privateComps = true;
   } else {
     Say("PRIVATE may not appear more than once in"
-        " derived type components"_en_US); // C738
+        " derived type components"_warn_en_US); // C738
   }
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::SequenceStmt &) {
   if (derivedTypeInfo_.sequence) {
     Say("SEQUENCE may not appear more than once in"
-        " derived type components"_en_US); // C738
+        " derived type components"_warn_en_US); // C738
   }
   derivedTypeInfo_.sequence = true;
   return false;
 }
 void DeclarationVisitor::Post(const parser::ComponentDecl &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   auto attrs{GetAttrs()};
   if (derivedTypeInfo_.privateComps &&
bool DeclarationVisitor::Pre(const parser::DataComponentDefStmt &x) {
   Walk(std::get<parser::DeclarationTypeSpec>(x.t));
   set_allowForwardReferenceToDerivedType(false);
   if (derivedTypeInfo_.sequence) { // C740
     if (const auto *declType{GetDeclTypeSpec()}) {
       if (!declType->AsIntrinsic() && !declType->IsSequenceType()) {
         if (GetAttrs().test(Attr::POINTER) &&
             context().IsEnabled(common::LanguageFeature::PointerInSeqType)) {
           if (context().ShouldWarn(common::LanguageFeature::PointerInSeqType)) {
-            Say("A sequence type data component that is a pointer to a non-sequence type is not standard"_en_US);
+            Say("A sequence type data component that is a pointer to a non-sequence type is not standard"_port_en_US);
           }
         } else {
           Say("A sequence type data component must either be of an intrinsic type or a derived sequence type"_err_en_US);
         }
       }
     }
   }
   Walk(std::get<std::list<parser::ComponentOrFill>>(x.t));
Attrs DeclarationVisitor::HandleSaveName(const SourceName &name, Attrs attrs) {
   return attrs;
 }
 
 // Record a name in a set of those to be saved.
 void DeclarationVisitor::AddSaveName(
     std::set<SourceName> &set, const SourceName &name) {
   auto pair{set.insert(name)};
   if (!pair.second) {
-    Say2(name, "SAVE attribute was already specified on '%s'"_en_US,
+    Say2(name, "SAVE attribute was already specified on '%s'"_warn_en_US,
         *pair.first, "Previous specification of SAVE attribute"_en_US);
   }
 }
 
 // Set the SAVE attribute on symbol unless it is implicitly saved anyway.
 void DeclarationVisitor::SetSaveAttr(Symbol &symbol) {
   if (!IsSaved(symbol)) {
     symbol.attrs().set(Attr::SAVE);

 // Return true if it is ok to declare this component in the current scope.
 // Otherwise, emit an error and return false.
 bool DeclarationVisitor::OkToAddComponent(
     const parser::Name &name, const Symbol *extends) {
   for (const Scope *scope{&currScope()}; scope;) {
     CHECK(scope->IsDerivedType());
     if (auto *prev{FindInScope(*scope, name)}) {
       if (!context().HasError(*prev)) {
-        auto msg{""_en_US};
+        parser::MessageFixedText msg;
         if (extends) {
           msg = "Type cannot be extended as it has a component named"
                 " '%s'"_err_en_US;
         } else if (prev->test(Symbol::Flag::ParentComp)) {
           msg = "'%s' is a parent type of this type and so cannot be"
                 " a component"_err_en_US;
         } else if (scope != &currScope()) {
           msg = "Component '%s' is already declared in a parent of this"
for (auto &name : x.v) {
     }
   }
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::LocalitySpec::Shared &x) {
   for (const auto &name : x.v) {
     if (!FindSymbol(name)) {
-      Say(name, "Variable '%s' with SHARED locality implicitly declared"_en_US);
+      Say(name,
+          "Variable '%s' with SHARED locality implicitly declared"_warn_en_US);
     }
     Symbol &prev{FindOrDeclareEnclosingEntity(name)};
     if (PassesSharedLocalityChecks(name, prev)) {
       MakeHostAssocSymbol(name, prev).set(Symbol::Flag::LocalityShared);
     }
   }
   return false;
 }
if (Symbol * symbol{name.symbol}) {
     } else if (IsDummy(*symbol) ||
         (!symbol->GetType() && FindCommonBlockContaining(*symbol))) {
       ConvertToObjectEntity(*symbol);
       ApplyImplicitRules(*symbol);
     }
     if (checkIndexUseInOwnBounds_ &&
         *checkIndexUseInOwnBounds_ == name.source) {
       Say(name,
-          "Implied DO index '%s' uses an object of the same name in its bounds expressions"_en_US,
+          "Implied DO index '%s' uses an object of the same name in its bounds expressions"_port_en_US,
           name.source);
     }
     return &name;
   }
   if (isImplicitNoneType()) {
     Say(name, "No explicit type declared for '%s'"_err_en_US);
     return nullptr;
   }
if (!symbol) {
     symbol = &MakeSymbol(name);
   }
   Attrs &attrs{symbol->attrs()};
   if (attrs.HasAny({Attr::PUBLIC, Attr::PRIVATE})) {
     // PUBLIC/PRIVATE already set: make it a fatal error if it changed
     Attr prev = attrs.test(Attr::PUBLIC) ? Attr::PUBLIC : Attr::PRIVATE;
     Say(name,
         WithSeverity(
-            "The accessibility of '%s' has already been specified as %s"_en_US,
+            "The accessibility of '%s' has already been specified as %s"_warn_en_US,
             attr != prev ? parser::Severity::Error : parser::Severity::Warning),
         MakeOpName(name), EnumToString(prev));
   } else {
     attrs.set(attr);
   }
   return *symbol;
 }
 

flang/lib/Semantics/semantics.cpp

if (it != activeIndexVars_.end()) {
     std::string kind{EnumToString(it->second.kind)};
     Say(location, std::move(message), kind, symbol.name())
         .Attach(it->second.location, "Enclosing %s construct"_en_US, kind);
   }
 }
 
 void SemanticsContext::WarnIndexVarRedefine(
     const parser::CharBlock &location, const Symbol &variable) {
-  CheckIndexVarRedefine(
-      location, variable, "Possible redefinition of %s variable '%s'"_en_US);
+  CheckIndexVarRedefine(location, variable,
+      "Possible redefinition of %s variable '%s'"_warn_en_US);
 }
 
 void SemanticsContext::CheckIndexVarRedefine(
     const parser::CharBlock &location, const Symbol &variable) {
   CheckIndexVarRedefine(
       location, variable, "Cannot redefine %s variable '%s'"_err_en_US);
 }
 

flang/test/Driver/fixed-free-flag.f90

 !------------------------------------
 ! EXPECTED OUTPUT FOR FREE FORM MODE
 !------------------------------------
 ! FREEFORM: Could not parse
 
 !-------------------------------------
 ! EXPECTED OUTPUT FOR FIXED FORM MODE
 !-------------------------------------
-! FIXEDFORM:free-form-test.f90:1:1: Character in fixed-form label field must be a digit
+! FIXEDFORM:free-form-test.f90:1:1: warning: Character in fixed-form label field must be a digit

flang/test/Evaluate/folding03.f90

module integer_tests
   ! expression because literal-constant are not signed so this would parse
   ! to -(2147483648_4) and 2147483648_4 is not accepted as a literal-constant.
   ! However, one can reach this value with operations.
   integer(4), parameter :: i4_nmax = -2147483647_4 - 1_4
 
   ! Integer division by zero are not tested here because they are handled as fatal
   ! errors in constants.
 
-  !WARN: INTEGER(4) negation overflowed
+  !WARN: warning: INTEGER(4) negation overflowed
   logical, parameter :: test_overflow_unary_minus1 = (-i4_nmax).EQ.i4_nmax
   logical, parameter :: test_no_overflow_unary_minus1 = (-i4_pmax).EQ.(i4_nmax+1_4)
   logical, parameter :: test_no_overflow_unary_plus1 = (+i4_pmax).EQ.i4_pmax
   logical, parameter :: test_no_overflow_unary_plus2 = (+i4_nmax).EQ.i4_nmax
 
-  !WARN: INTEGER(4) addition overflowed
+  !WARN: warning: INTEGER(4) addition overflowed
   logical, parameter :: test_overflow_add1 = (i4_pmax+1_4).EQ.i4_nmax
-  !WARN: INTEGER(4) addition overflowed
+  !WARN: warning: INTEGER(4) addition overflowed
   logical, parameter :: test_overflow_add2 = (i4_nmax + (-1_4)).EQ.i4_pmax
-  !WARN: INTEGER(4) addition overflowed
+  !WARN: warning: INTEGER(4) addition overflowed
   logical, parameter :: test_overflow_add3 = (i4_pmax + i4_pmax).EQ.(-2_4)
-  !WARN: INTEGER(4) addition overflowed
+  !WARN: warning: INTEGER(4) addition overflowed
   logical, parameter :: test_overflow_add4 = (i4_nmax + i4_nmax).EQ.(0_4)
   logical, parameter :: test_no_overflow_add1 = (i4_pmax + 0_4).EQ.i4_pmax
   logical, parameter :: test_no_overflow_add2 = (i4_nmax + (-0_4)).EQ.i4_nmax
   logical, parameter :: test_no_overflow_add3 = (i4_pmax + i4_nmax).EQ.(-1_4)
   logical, parameter :: test_no_overflow_add4 = (i4_nmax + i4_pmax).EQ.(-1_4)
 
-  !WARN: INTEGER(4) subtraction overflowed
+  !WARN: warning: INTEGER(4) subtraction overflowed
   logical, parameter :: test_overflow_sub1 = (i4_nmax - 1_4).EQ.i4_pmax
-  !WARN: INTEGER(4) subtraction overflowed
+  !WARN: warning: INTEGER(4) subtraction overflowed
   logical, parameter :: test_overflow_sub2 = (i4_pmax - (-1_4)).EQ.i4_nmax
-  !WARN: INTEGER(4) subtraction overflowed
+  !WARN: warning: INTEGER(4) subtraction overflowed
   logical, parameter :: test_overflow_sub3 = (i4_nmax - i4_pmax).EQ.(1_4)
-  !WARN: INTEGER(4) subtraction overflowed
+  !WARN: warning: INTEGER(4) subtraction overflowed
   logical, parameter :: test_overflow_sub4 = (i4_pmax - i4_nmax).EQ.(-1_4)
   logical, parameter :: test_no_overflow_sub1 = (i4_nmax - 0_4).EQ.i4_nmax
   logical, parameter :: test_no_overflow_sub2 = (i4_pmax - (-0_4)).EQ.i4_pmax
   logical, parameter :: test_no_overflow_sub3 = (i4_nmax - i4_nmax).EQ.0_4
   logical, parameter :: test_no_overflow_sub4 = (i4_pmax - i4_pmax).EQ.0_4
 
 
-  !WARN: INTEGER(4) multiplication overflowed
+  !WARN: warning: INTEGER(4) multiplication overflowed
   logical, parameter :: test_overflow_mult1 = (i4_pmax*2_4).EQ.(-2_4)
-  !WARN: INTEGER(4) multiplication overflowed
+  !WARN: warning: INTEGER(4) multiplication overflowed
   logical, parameter :: test_overflow_mult2 = (i4_nmax*2_4).EQ.(0_4)
-  !WARN: INTEGER(4) multiplication overflowed
+  !WARN: warning: INTEGER(4) multiplication overflowed
   logical, parameter :: test_overflow_mult3 = (i4_nmax*i4_nmax).EQ.(0_4)
-  !WARN: INTEGER(4) multiplication overflowed
+  !WARN: warning: INTEGER(4) multiplication overflowed
   logical, parameter :: test_overflow_mult4 = (i4_pmax*i4_pmax).EQ.(1_4)
 
-  !WARN: INTEGER(4) division overflowed
+  !WARN: warning: INTEGER(4) division overflowed
   logical, parameter :: test_overflow_div1 = (i4_nmax/(-1_4)).EQ.(i4_nmax)
   logical, parameter :: test_no_overflow_div1 = (i4_nmax/(-2_4)).EQ.(1_4 + i4_pmax/2_4)
   logical, parameter :: test_no_overflow_div2 = (i4_nmax/i4_nmax).EQ.(1_4)
 
-  !WARN: INTEGER(4) power overflowed
+  !WARN: warning: INTEGER(4) power overflowed
   logical, parameter :: test_overflow_pow1 = (i4_pmax**2_4).EQ.(1_4)
-  !WARN: INTEGER(4) power overflowed
+  !WARN: warning: INTEGER(4) power overflowed
   logical, parameter :: test_overflow_pow3 = (i4_nmax**2_4).EQ.(0_4)
   logical, parameter :: test_no_overflow_pow1 = ((-1_4)**i4_nmax).EQ.(1_4)
   logical, parameter :: test_no_overflow_pow2 = ((-1_4)**i4_pmax).EQ.(-1_4)
 
 end module
 
 module real_tests
   ! Test real(4) operation folding on edge cases (inf and NaN)
 
   real(4), parameter :: r4_pmax = 3.4028235E38
   real(4), parameter :: r4_nmax = -3.4028235E38
-  !WARN: invalid argument on division
+  !WARN: warning: invalid argument on division
   real(4), parameter :: r4_nan = 0._4/0._4
   TEST_ISNAN(r4_nan)
-  !WARN: division by zero
+  !WARN: warning: division by zero
   real(4), parameter :: r4_pinf = 1._4/0._4
-  !WARN: division by zero
+  !WARN: warning: division by zero
   real(4), parameter :: r4_ninf = -1._4/0._4
 
   logical, parameter :: test_r4_nan_parentheses1 = .NOT.(((r4_nan)).EQ.r4_nan)
   logical, parameter :: test_r4_nan_parentheses2 = .NOT.(((r4_nan)).NE.r4_nan)
   logical, parameter :: test_r4_pinf_parentheses = ((r4_pinf)).EQ.r4_pinf
   logical, parameter :: test_r4_ninf_parentheses = ((r4_ninf)).EQ.r4_ninf
 
   ! No warnings expected
   logical, parameter :: test_r4_negation1 = (-r4_pmax).EQ.r4_nmax
   logical, parameter :: test_r4_negation2 = (-r4_nmax).EQ.r4_pmax
   logical, parameter :: test_r4_negation3 = (-r4_pinf).EQ.r4_ninf
   logical, parameter :: test_r4_negation4 = (-r4_ninf).EQ.r4_pinf
   logical, parameter :: test_r4_plus1 = (+r4_pmax).EQ.r4_pmax
   logical, parameter :: test_r4_plus2 = (+r4_nmax).EQ.r4_nmax
   logical, parameter :: test_r4_plus3 = (+r4_pinf).EQ.r4_pinf
   logical, parameter :: test_r4_plus4 = (+r4_ninf).EQ.r4_ninf
   ! NaN propagation , no warnings expected (quiet)
   real(4), parameter :: r4_nan_minus = (-r4_nan)
   TEST_ISNAN(r4_nan_minus)
   real(4), parameter :: r4_nan_plus = (+r4_nan)
   TEST_ISNAN(r4_nan_plus)
 
-  !WARN: overflow on addition
+  !WARN: warning: overflow on addition
   logical, parameter :: test_inf_r4_add9 = (r4_pmax + r4_pmax).eq.(r4_pinf)
-  !WARN: overflow on addition
+  !WARN: warning: overflow on addition
   logical, parameter :: test_inf_r4_add10 = (r4_nmax + r4_nmax).eq.(r4_ninf)
-  !WARN: overflow on subtraction
+  !WARN: warning: overflow on subtraction
   logical, parameter :: test_inf_r4_sub9 = (r4_pmax - r4_nmax).eq.(r4_pinf)
-  !WARN: overflow on subtraction
+  !WARN: warning: overflow on subtraction
   logical, parameter :: test_inf_r4_sub10 = (r4_nmax - r4_pmax).eq.(r4_ninf)
 
   ! No warnings expected below (inf propagation).
   logical, parameter :: test_inf_r4_add1 = (r4_pinf + r4_pinf).EQ.(r4_pinf)
   logical, parameter :: test_inf_r4_add2 = (r4_ninf + r4_ninf).EQ.(r4_ninf)
   logical, parameter :: test_inf_r4_add3 = (r4_pinf + r4_nmax).EQ.(r4_pinf)
   logical, parameter :: test_inf_r4_add4 = (r4_pinf + r4_pmax).EQ.(r4_pinf)
   logical, parameter :: test_inf_r4_add5 = (r4_ninf + r4_pmax).EQ.(r4_ninf)
   logical, parameter :: test_inf_r4_add6 = (r4_ninf + r4_nmax).EQ.(r4_ninf)
   logical, parameter :: test_inf_r4_add7 = (r4_ninf + 0._4).EQ.(r4_ninf)
   logical, parameter :: test_inf_r4_add8 = (r4_pinf + 0._4).EQ.(r4_pinf)
 
-  !WARN: invalid argument on subtraction
+  !WARN: warning: invalid argument on subtraction
   real(4), parameter :: r4_nan_sub1 = r4_pinf - r4_pinf
   TEST_ISNAN(r4_nan_sub1)
-  !WARN: invalid argument on subtraction
+  !WARN: warning: invalid argument on subtraction
   real(4), parameter :: r4_nan_sub2 = r4_ninf - r4_ninf
   TEST_ISNAN(r4_nan_sub2)
-  !WARN: invalid argument on addition
+  !WARN: warning: invalid argument on addition
   real(4), parameter :: r4_nan_add1 = r4_ninf + r4_pinf
   TEST_ISNAN(r4_nan_add1)
-  !WARN: invalid argument on addition
+  !WARN: warning: invalid argument on addition
   real(4), parameter :: r4_nan_add2 = r4_pinf + r4_ninf
   TEST_ISNAN(r4_nan_add2)
 
   ! No warnings expected here (quite NaN propagation)
   real(4), parameter :: r4_nan_sub3 = 0._4 - r4_nan
   TEST_ISNAN(r4_nan_sub3)
   real(4), parameter :: r4_nan_sub4 = r4_nan - r4_pmax
   TEST_ISNAN(r4_nan_sub4)
   real(4), parameter :: r4_nan_sub5 = r4_nan - r4_nmax
   TEST_ISNAN(r4_nan_sub5)
   real(4), parameter :: r4_nan_sub6 = r4_nan - r4_nan
   TEST_ISNAN(r4_nan_sub6)
   real(4), parameter :: r4_nan_add3 = 0._4 + r4_nan
   TEST_ISNAN(r4_nan_add3)
   real(4), parameter :: r4_nan_add4 = r4_nan + r4_pmax
   TEST_ISNAN(r4_nan_add4)
   real(4), parameter :: r4_nan_add5 = r4_nmax + r4_nan
   TEST_ISNAN(r4_nan_add5)
   real(4), parameter :: r4_nan_add6 = r4_nan + r4_nan
   TEST_ISNAN(r4_nan_add6)
 
-  !WARN: overflow on multiplication
+  !WARN: warning: overflow on multiplication
   logical, parameter :: test_inf_r4_mult1 = (1.5_4*r4_pmax).eq.(r4_pinf)
-  !WARN: overflow on multiplication
+  !WARN: warning: overflow on multiplication
   logical, parameter :: test_inf_r4_mult2 = (1.5_4*r4_nmax).eq.(r4_ninf)
-  !WARN: overflow on division
+  !WARN: warning: overflow on division
   logical, parameter :: test_inf_r4_div1 = (r4_nmax/(-0.5_4)).eq.(r4_pinf)
-  !WARN: overflow on division
+  !WARN: warning: overflow on division
   logical, parameter :: test_inf_r4_div2 = (r4_pmax/(-0.5_4)).eq.(r4_ninf)
 
   ! No warnings expected below (inf propagation).
   logical, parameter :: test_inf_r4_mult3 = (r4_pinf*r4_pinf).EQ.(r4_pinf)
   logical, parameter :: test_inf_r4_mult4 = (r4_ninf*r4_ninf).EQ.(r4_pinf)
   logical, parameter :: test_inf_r4_mult5 = (r4_pinf*0.1_4).EQ.(r4_pinf)
   logical, parameter :: test_inf_r4_mult6 = (r4_ninf*r4_nmax).EQ.(r4_pinf)
   logical, parameter :: test_inf_r4_div3 = (r4_pinf/0.).EQ.(r4_pinf)
   logical, parameter :: test_inf_r4_div4 = (r4_ninf/0.).EQ.(r4_ninf)
   logical, parameter :: test_inf_r4_div5 = (0./r4_pinf).EQ.(0.)
   logical, parameter :: test_inf_r4_div6 = (0./r4_ninf).EQ.(0.)
   logical, parameter :: test_inf_r4_div7 = (r4_pinf/r4_pmax).EQ.(r4_pinf)
   logical, parameter :: test_inf_r4_div8 = (r4_pinf/r4_nmax).EQ.(r4_ninf)
   logical, parameter :: test_inf_r4_div9 = (r4_nmax/r4_pinf).EQ.(0.)
   logical, parameter :: test_inf_r4_div10 = (r4_nmax/r4_ninf).EQ.(0.)
 
-  !WARN: invalid argument on division
+  !WARN: warning: invalid argument on division
   real(4), parameter :: r4_nan_div1 = 0._4/0._4
   TEST_ISNAN(r4_nan_div1)
-  !WARN: invalid argument on division
+  !WARN: warning: invalid argument on division
   real(4), parameter :: r4_nan_div2 = r4_ninf/r4_ninf
   TEST_ISNAN(r4_nan_div2)
-  !WARN: invalid argument on division
+  !WARN: warning: invalid argument on division
   real(4), parameter :: r4_nan_div3 = r4_ninf/r4_pinf
   TEST_ISNAN(r4_nan_div3)
-  !WARN: invalid argument on division
+  !WARN: warning: invalid argument on division
   real(4), parameter :: r4_nan_div4 = r4_pinf/r4_ninf
   TEST_ISNAN(r4_nan_div4)
-  !WARN: invalid argument on division
+  !WARN: warning: invalid argument on division
   real(4), parameter :: r4_nan_div5 = r4_pinf/r4_pinf
   TEST_ISNAN(r4_nan_div5)
-  !WARN: invalid argument on multiplication
+  !WARN: warning: invalid argument on multiplication
   real(4), parameter :: r4_nan_mult1 = r4_pinf*0._4
   TEST_ISNAN(r4_nan_mult1)
-  !WARN: invalid argument on multiplication
+  !WARN: warning: invalid argument on multiplication
   real(4), parameter :: r4_nan_mult2 = 0._4*r4_ninf
   TEST_ISNAN(r4_nan_mult2)
 
   ! No warnings expected here (quite NaN propagation)
   real(4), parameter :: r4_nan_div6 = 0._4/r4_nan
   TEST_ISNAN(r4_nan_div6)
   real(4), parameter :: r4_nan_div7 = r4_nan/r4_nan
   TEST_ISNAN(r4_nan_div7)

flang/test/Evaluate/folding04.f90

 ! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test intrinsic function folding edge case (both expected value and messages)
 ! These tests make assumptions regarding real(4) extrema.
 
 #define TEST_ISNAN(v) logical, parameter :: test_##v =.NOT.(v.EQ.v)
 
 
 module real_tests
   ! Test real(4) intrinsic folding on edge cases (inf and NaN)
 
   real(4), parameter :: r4_pmax = 3.4028235E38
   real(4), parameter :: r4_nmax = -3.4028235E38
-  !WARN: invalid argument on division
+  !WARN: warning: invalid argument on division
   real(4), parameter :: r4_nan = 0._4/0._4
-  !WARN: division by zero
+  !WARN: warning: division by zero
   real(4), parameter :: r4_pinf = 1._4/0._4
-  !WARN: division by zero
+  !WARN: warning: division by zero
   real(4), parameter :: r4_ninf = -1._4/0._4
 
-  !WARN: invalid argument on intrinsic function
+  !WARN: warning: invalid argument on intrinsic function
   real(4), parameter :: nan_r4_acos1 = acos(1.1)
   TEST_ISNAN(nan_r4_acos1)
-  !WARN: invalid argument on intrinsic function
+  !WARN: warning: invalid argument on intrinsic function
   real(4), parameter :: nan_r4_acos2 = acos(r4_pmax)
   TEST_ISNAN(nan_r4_acos2)
-  !WARN: invalid argument on intrinsic function
+  !WARN: warning: invalid argument on intrinsic function
   real(4), parameter :: nan_r4_acos3 = acos(r4_nmax)
   TEST_ISNAN(nan_r4_acos3)
-  !WARN: invalid argument on intrinsic function
+  !WARN: warning: invalid argument on intrinsic function
   real(4), parameter :: nan_r4_acos4 = acos(r4_ninf)
   TEST_ISNAN(nan_r4_acos4)
-  !WARN: invalid argument on intrinsic function
+  !WARN: warning: invalid argument on intrinsic function
   real(4), parameter :: nan_r4_acos5 = acos(r4_pinf)
   TEST_ISNAN(nan_r4_acos5)
 
-  !WARN: overflow on intrinsic function
+  !WARN: warning: overflow on intrinsic function
   logical, parameter :: test_exp_overflow = exp(256._4).EQ.r4_pinf
 end module
 
 module parentheses
   ! Test parentheses in folding (they are kept around constants to keep the
   ! distinction between variable and expressions and require special care).
   real(4), parameter :: x_nop = 0.1_4
   real(4), parameter :: x_p = (x_nop)
   logical, parameter :: test_parentheses1 = acos(x_p).EQ.acos(x_nop)
 end module
 
 module specific_extremums
   ! f18 accepts all type kinds for the arguments of specific extremum intrinsics
   ! instead of of only default kind (or double precision for DMAX1 and DMIN1).
   ! This extensions is implemented by using the related generic intrinsic and
   ! converting the result.
   ! The tests below are cases where an implementation that converts the arguments to the
   ! standard required types instead would give different results than the implementation
   ! specified for f18 (converting the result).
-  integer(8), parameter :: max_i32_8 = 2_8**31-1  
+  integer(8), parameter :: max_i32_8 = 2_8**31-1
   integer, parameter :: expected_min0 = int(min(max_i32_8, 2_8*max_i32_8), 4)
-  !WARN: argument types do not match specific intrinsic 'min0' requirements; using 'min' generic instead and converting the result to INTEGER(4) if needed
+  !WARN: portability: argument types do not match specific intrinsic 'min0' requirements; using 'min' generic instead and converting the result to INTEGER(4) if needed
   integer, parameter :: result_min0 =  min0(max_i32_8, 2_8*max_i32_8)
   ! result_min0 would be -2  if arguments were converted to default integer.
   logical, parameter :: test_min0 = expected_min0 .EQ. result_min0
 
   real, parameter :: expected_amax0 = real(max(max_i32_8, 2_8*max_i32_8), 4)
-  !WARN: argument types do not match specific intrinsic 'amax0' requirements; using 'max' generic instead and converting the result to REAL(4) if needed
+  !WARN: portability: argument types do not match specific intrinsic 'amax0' requirements; using 'max' generic instead and converting the result to REAL(4) if needed
   real, parameter :: result_amax0 = amax0(max_i32_8, 2_8*max_i32_8)
   ! result_amax0 would be 2.1474836E+09 if arguments were converted to default integer first.
   logical, parameter :: test_amax0 = expected_amax0 .EQ. result_amax0
 end module

flang/test/Evaluate/folding14.f90

 ! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test folding of isnan() extension
 module m1
   logical, parameter :: results(*) = isnan([ &
     0., &
     -0., &
-!WARN: division by zero
+!WARN: warning: division by zero
     1./0., &
-!WARN: invalid argument on division
+!WARN: warning: invalid argument on division
     0./0., &
     real(z'7ff80001',kind=4), &
     real(z'fff80001',kind=4), &
     real(z'7ffc0000',kind=4), &
     real(z'7ffe0000',kind=4) ])
   logical, parameter :: expected(*) = [ &
     .false., .false., .false., .true., .true., .true., .true., .true. ]
   logical, parameter :: test_isnan = all(results .eqv. expected)
 end module

flang/test/Evaluate/folding28.f90

module m
   logical, parameter :: test_h8 = h8 == h8z
   real(8), parameter :: sqrt_h8 = sqrt(h8), sqrt_h8z = z'5fefffffffffffff'
   logical, parameter :: test_sqrt_h8 = sqrt_h8 == sqrt_h8z
   real(8), parameter :: sqr_sqrt_h8 = sqrt_h8 * sqrt_h8, sqr_sqrt_h8z = z'7feffffffffffffe'
   logical, parameter :: test_sqr_sqrt_h8 = sqr_sqrt_h8 == sqr_sqrt_h8z
   ! -0 (sqrt is -0)
   real(8), parameter :: n08 = z'8000000000000000'
   real(8), parameter :: sqrt_n08 = sqrt(n08)
-!WARN: division by zero
+  !WARN: warning: division by zero
   real(8), parameter :: inf_n08 = 1.0_8 / sqrt_n08, inf_n08z = z'fff0000000000000'
   logical, parameter :: test_n08 = inf_n08 == inf_n08z
   ! min normal
   real(8), parameter :: t8 = tiny(1.0_8), t8z = z'0010000000000000'
   logical, parameter :: test_t8 = t8 == t8z
   real(8), parameter :: sqrt_t8 = sqrt(t8), sqrt_t8z = z'2000000000000000'
   logical, parameter :: test_sqrt_t8 = sqrt_t8 == sqrt_t8z
   real(8), parameter :: sqr_sqrt_t8 = sqrt_t8 * sqrt_t8

flang/test/Frontend/prescanner-diag.f90

 
 ! Test with -fsyntax-only (i.e. ParseSyntaxOnlyAction, stops after semantic checks)
 ! RUN: %flang -fsyntax-only -I %S/Inputs/ %s 2>&1 | FileCheck %s
 ! RUN: %flang_fc1 -fsyntax-only -I %S/Inputs/ %s 2>&1 | FileCheck %s
 
 !-----------------------
 ! EXPECTED OUTPUT
 !-----------------------
-! CHECK: prescanner-diag.f90:27:20: #include: extra stuff ignored after file name
-! CHECK: prescanner-diag.f90:28:20: #include: extra stuff ignored after file name
+! CHECK: prescanner-diag.f90:27:20: portability: #include: extra stuff ignored after file name
+! CHECK: prescanner-diag.f90:28:20: portability: #include: extra stuff ignored after file name
 
 !-------
 ! INPUT
 !-------
 #include <empty.h> comment
 #include "empty.h" comment
 end

flang/test/Preprocessing/include-comment.F90

 ! RUN: %flang -I%S -E %s 2>&1 | FileCheck %s
 ! CHECK-NOT: :3:
 #include <empty.h> ! comment
 ! CHECK-NOT: :5:
 #include <empty.h> /* comment */
 ! CHECK-NOT: :7:
 #include <empty.h> !comment
-! CHECK: :9:20: #include: extra stuff ignored after file name
+! CHECK: :9:20: portability: #include: extra stuff ignored after file name
 #include <empty.h> comment
 ! CHECK-NOT: :11:
 #include "empty.h" ! comment
 ! CHECK-NOT: :13:
 #include "empty.h" /* comment */
 ! CHECK-NOT: :15:
 #include "empty.h" !comment
-! CHECK: :17:20: #include: extra stuff ignored after file name
+! CHECK: :17:20: portability: #include: extra stuff ignored after file name
 #include "empty.h" comment
 end

flang/test/Semantics/call25.f90

program main
   !CHECK: error: Actual argument function associated with procedure dummy argument 'f=' has incompatible result type
   call subr1(notChar)
   call subr2(explicitLength)
   call subr2(assumedLength)
   !CHECK: error: Actual argument function associated with procedure dummy argument 'f=' has incompatible result type
   call subr2(notChar)
   call subr3(explicitLength)
   call subr3(assumedLength)
-  !CHECK: Warning: if the procedure's interface were explicit, this reference would be in error:
+  !CHECK: warning: If the procedure's interface were explicit, this reference would be in error:
   !CHECK: Actual argument function associated with procedure dummy argument 'f=' has incompatible result type
   call subr3(notChar)
 end program