[flang] [NFC] Repair build with GCC 7.3

[klausler]

Summary

Work around two problems with GCC 7.3.
One is its inability to implement "constexpr operator=(...) = default;"
in a class with a std::optional<> component; another is a legitimate-
looking warning about an unused variable.

[clementval]

LGTM.

We experienced the bug in our CI on Summit and this patch fixes the problem for us. We test with GCC 7.5.

[mstorsjo]

Thanks! FWIW, the same issue also crops up if compiling with clang in an environment that uses libstdc++ from GCC 7 (i.e. building with clang on Ubuntu 18.04), I'll send a separate patch for fixing that.

Also note that building flang seems to fail entirely after D104167, see e.g. https://lab.llvm.org/buildbot/#/builders/132.

[lei]

This broke the flang bot: https://lab.llvm.org/buildbot/#/builders/21/builds/17760
Please provide fix or pull the patch to unblock the bot.

[clementval]

In D104731#2835848, @lei wrote:

This broke the flang bot: https://lab.llvm.org/buildbot/#/builders/21/builds/17760
Please provide fix or pull the patch to unblock the bot.

The bot started to fail after a change in mlir and not after this patch.

flang/include/flang/Evaluate/type.h

public:
   constexpr int kind() const {
     CHECK(kind_ > 0);
     return kind_;
   }
   constexpr const semantics::ParamValue *charLengthParamValue() const {
     return charLengthParamValue_;
   }
   constexpr std::optional<std::int64_t> knownLength() const {
+#if !__clang__ && __GNUC__ == 7
+    if (knownLength_ < 0) {
+      return std::nullopt;
+    }
+#endif
     return knownLength_;
   }
   std::optional<Expr<SubscriptInteger>> GetCharLength() const;
 
   std::size_t GetAlignment(const FoldingContext &) const;
   std::optional<Expr<SubscriptInteger>> MeasureSizeInBytes(
       FoldingContext &, bool aligned) const;
 
enum SpecialKind {
     AssumedTypeKind = -3, // TYPE(*)
   };
 
   constexpr DynamicType() {}
 
   TypeCategory category_{TypeCategory::Derived}; // overridable default
   int kind_{0};
   const semantics::ParamValue *charLengthParamValue_{nullptr};
+#if !__clang__ && __GNUC__ == 7
+  // GCC 7's optional<> lacks a constexpr operator=
+  std::int64_t knownLength_{-1};
+#else
   std::optional<std::int64_t> knownLength_;
+#endif
   const semantics::DerivedTypeSpec *derived_{nullptr}; // TYPE(T), CLASS(T)
 };
 
 // Return the DerivedTypeSpec of a DynamicType if it has one.
 const semantics::DerivedTypeSpec *GetDerivedTypeSpec(const DynamicType &);
 const semantics::DerivedTypeSpec *GetDerivedTypeSpec(
     const std::optional<DynamicType> &);
 const semantics::DerivedTypeSpec *GetParentTypeSpec(

flang/lib/Evaluate/formatting.cpp

llvm::raw_ostream &StructureConstructor::AsFortran(llvm::raw_ostream &o) const {
   }
   return o << ')';
 }
 
 std::string DynamicType::AsFortran() const {
   if (derived_) {
     CHECK(category_ == TypeCategory::Derived);
     return DerivedTypeSpecAsFortran(*derived_);
-  } else if (charLengthParamValue_ || knownLength_) {
+  } else if (charLengthParamValue_ || knownLength()) {
     std::string result{"CHARACTER(KIND="s + std::to_string(kind_) + ",LEN="};
-    if (knownLength_) {
-      result += std::to_string(*knownLength_) + "_8";
+    if (knownLength()) {
+      result += std::to_string(*knownLength()) + "_8";
     } else if (charLengthParamValue_->isAssumed()) {
       result += '*';
     } else if (charLengthParamValue_->isDeferred()) {
       result += ':';
     } else if (const auto &length{charLengthParamValue_->GetExplicit()}) {
       result += length->AsFortran();
     }
     return result + ')';

flang/lib/Evaluate/type.cpp

 
 template <typename A> inline bool PointeeComparison(const A *x, const A *y) {
   return x == y || (x && y && *x == *y);
 }
 
 bool DynamicType::operator==(const DynamicType &that) const {
   return category_ == that.category_ && kind_ == that.kind_ &&
       PointeeComparison(charLengthParamValue_, that.charLengthParamValue_) &&
-      knownLength_.has_value() == that.knownLength_.has_value() &&
-      (!knownLength_ || *knownLength_ == *that.knownLength_) &&
+      knownLength().has_value() == that.knownLength().has_value() &&
+      (!knownLength() || *knownLength() == *that.knownLength()) &&
       PointeeComparison(derived_, that.derived_);
 }
 
 std::optional<Expr<SubscriptInteger>> DynamicType::GetCharLength() const {
   if (category_ == TypeCategory::Character) {
-    if (knownLength_) {
-      return AsExpr(Constant<SubscriptInteger>(*knownLength_));
+    if (knownLength()) {
+      return AsExpr(Constant<SubscriptInteger>(*knownLength()));
     } else if (charLengthParamValue_) {
       if (auto length{charLengthParamValue_->GetExplicit()}) {
         return ConvertToType<SubscriptInteger>(std::move(*length));
       }
     }
   }
   return std::nullopt;
 }

 bool DynamicType::IsAssumedLengthCharacter() const {
   return category_ == TypeCategory::Character && charLengthParamValue_ &&
       charLengthParamValue_->isAssumed();
 }
 
 bool DynamicType::IsNonConstantLengthCharacter() const {
   if (category_ != TypeCategory::Character) {
     return false;
-  } else if (knownLength_) {
+  } else if (knownLength()) {
     return false;
   } else if (!charLengthParamValue_) {
     return true;
   } else if (const auto &expr{charLengthParamValue_->GetExplicit()}) {
     return !IsConstantExpr(*expr);
   } else {
     return true;
   }

flang/lib/Semantics/check-declarations.cpp

nameToInfo_[generic.name()].emplace_back(
         ProcedureInfo{kind, specific, procedure});
   }
 }
 
 void DistinguishabilityHelper::Check(const Scope &scope) {
   for (const auto &[name, info] : nameToInfo_) {
     auto count{info.size()};
     for (std::size_t i1{0}; i1 < count - 1; ++i1) {
-      const auto &[kind1, symbol1, proc1] = info[i1];
+      const auto &[kind, symbol, proc]{info[i1]};
       for (std::size_t i2{i1 + 1}; i2 < count; ++i2) {
-        const auto &[kind2, symbol2, proc2] = info[i2];
-        auto distinguishable{kind1.IsName()
+        auto distinguishable{kind.IsName()
                 ? evaluate::characteristics::Distinguishable
                 : evaluate::characteristics::DistinguishableOpOrAssign};
-        if (!distinguishable(proc1, proc2)) {
-          SayNotDistinguishable(
-              GetTopLevelUnitContaining(scope), name, kind1, symbol1, symbol2);
+        if (!distinguishable(proc, info[i2].procedure)) {
+          SayNotDistinguishable(GetTopLevelUnitContaining(scope), name, kind,
+              symbol, info[i2].symbol);
         }
       }
     }
   }
 }
 
 void DistinguishabilityHelper::SayNotDistinguishable(const Scope &scope,
     const SourceName &name, GenericKind kind, const Symbol &proc1,