[flang] Fix pimpl idiom for IntrinsicProcTable.

[Meinersbur]

Summary

The class IntrinsicProcTable uses the pimpl idiom and manages its own pointer-to-implementation. However, it violates the rule-of-five and does not implement a move-constructor or assignment-operator. Due to differences between compilers in implementation copy elision, these may or may not be used. Due to the missing user implementation for resource handling, using the results in runtime errors.

Fix my using std::unique_ptr instead of custom resource management.

[Meinersbur]

Add \#include <memory.h> to ensure std::unique_ptr is available in idioms.h

[klausler]

flang/include/flang/Common/idioms.h

35

Please maintain alphabetical ordering of standard headers.

[Meinersbur]

• Sort includes

flang/include/flang/Common/idioms.h

 #endif
 #if !__clang__ && defined __GNUC__ && __GNUC__ < 7
 #error g++ >= 7.2 is required
 #endif
 
 #include "llvm/Support/Compiler.h"
 #include <functional>
 #include <list>
+#include <memory>
 #include <optional>
 #include <string>
 #include <tuple>
 #include <type_traits>
 #include <variant>
 
 #if __GNUC__ == 7
 // Avoid a deduction bug in GNU 7.x headers by forcing the answer.
 namespace std {
 template <typename A>
 struct is_trivially_copy_constructible<list<A>> : false_type {};
 template <typename A>
 struct is_trivially_copy_constructible<optional<list<A>>> : false_type {};
 } // namespace std

 
 template <typename T> constexpr T &Deref(T *p, const char *file, int line) {
   if (!p) {
     Fortran::common::die("nullptr dereference at %s(%d)", file, line);
   }
   return *p;
 }
 
+template <typename T>
+constexpr T &Deref(const std::unique_ptr<T> &p, const char *file, int line) {
+  if (!p) {
+    Fortran::common::die("nullptr dereference at %s(%d)", file, line);
+  }
+  return *p;
+}
+
 // Given a const reference to a value, return a copy of the value.
 template <typename A> A Clone(const A &x) { return x; }
 
 // C++ does a weird and dangerous thing when deducing template type parameters
 // from function arguments: lvalue references are allowed to match rvalue
 // reference arguments.  Template function declarations like
 //   template<typename A> int foo(A &&);
 // need to be protected against this C++ language feature when functions

flang/include/flang/Evaluate/intrinsics.h

 #define FORTRAN_EVALUATE_INTRINSICS_H_
 
 #include "call.h"
 #include "characteristics.h"
 #include "type.h"
 #include "flang/Common/default-kinds.h"
 #include "flang/Parser/char-block.h"
 #include "flang/Parser/message.h"
+#include <memory>
 #include <optional>
 #include <string>
 
 namespace llvm {
 class raw_ostream;
 }
 
 namespace Fortran::evaluate {

 ENUM_CLASS(IntrinsicClass, atomicSubroutine, collectiveSubroutine,
     elementalFunction, elementalSubroutine, inquiryFunction, pureSubroutine,
     impureSubroutine, transformationalFunction, noClass)
 
 class IntrinsicProcTable {
 private:
   class Implementation;
 
+  IntrinsicProcTable() = default;
+
 public:
   ~IntrinsicProcTable();
+  IntrinsicProcTable(IntrinsicProcTable &&) = default;
+
   static IntrinsicProcTable Configure(
       const common::IntrinsicTypeDefaultKinds &);
 
   // Check whether a name should be allowed to appear on an INTRINSIC
   // statement.
   bool IsIntrinsic(const std::string &) const;
 
   // Inquiry intrinsics are defined in section 16.7, table 16.1
public:
   // Illegal name for an intrinsic used to avoid cascading error messages when
   // constant folding.
   static const inline std::string InvalidName{
       "(invalid intrinsic function call)"};
 
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
-  Implementation *impl_{nullptr}; // owning pointer
+  std::unique_ptr<Implementation> impl_;
 };
 
 // Check if an intrinsic explicitly allows its INTENT(OUT) arguments to be
 // allocatable coarrays.
 bool AcceptsIntentOutAllocatableCoarray(const std::string &);
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_INTRINSICS_H_

flang/lib/Evaluate/intrinsics.cpp

 DynamicType IntrinsicProcTable::Implementation::GetSpecificType(
     const TypePattern &pattern) const {
   const CategorySet &set{pattern.categorySet};
   CHECK(set.count() == 1);
   TypeCategory category{set.LeastElement().value()};
   return DynamicType{category, defaults_.GetDefaultKind(category)};
 }
 
-IntrinsicProcTable::~IntrinsicProcTable() {
-  // Discard the configured tables.
-  delete impl_;
-  impl_ = nullptr;
-}
+IntrinsicProcTable::~IntrinsicProcTable() = default;
 
 IntrinsicProcTable IntrinsicProcTable::Configure(
     const common::IntrinsicTypeDefaultKinds &defaults) {
   IntrinsicProcTable result;
-  result.impl_ = new IntrinsicProcTable::Implementation(defaults);
+  result.impl_ = std::make_unique<IntrinsicProcTable::Implementation>(defaults);
   return result;
 }
 
 bool IntrinsicProcTable::IsIntrinsic(const std::string &name) const {
   return DEREF(impl_).IsIntrinsic(name);
 }
 
 IntrinsicClass IntrinsicProcTable::GetIntrinsicClass(