[flang] Fix a crash when creating generics from a copy

[PeteSteinfeld]

Summary

When a program unit creates a generic based on one defined in a module, the
function CopyFrom() is called to create the GenericDetails. This function
copied the specificProcs_ but failed to copy the bindingNames_. If the
function CheckGeneric() then gets called, it tries to index into the empty
binding names and causes the crash.

I fixed this by adding code to CopyFrom() to copy the binding names.

I also added a test that causes the crash.

[tskeith]

flang/lib/Semantics/symbol.cpp

212

I think that specificProcs_ and bindingNames_ are supposed to be parallel vectors; at least that is the assumption in CheckHelper::CheckGeneric. So this should be written as a single loop that pushes onto the two lists at the same time. As it's written it looks like the two loops might push different numbers of elements on the two lists.

One thing that suggests that the above assumption is wrong is the existence of this constructor: GenericDetails(const SymbolVector &specificProcs);. But I'm not sure it is ever used, so it would be good if you can delete it as part of this change.

[PeteSteinfeld]

flang/lib/Semantics/symbol.cpp

212

After doing some testing, I believe that you're correct that they're supposed to be parallel vectors. I'll put some calls to CHECK() into CopyFrom() to verify that their sizes match and copy them as pairs.

You're also correct that the constructor GenericDetails(const SymbolVector &specificProcs) is not used. I'll delete it.

Thanks for the guidance!

[PeteSteinfeld]

With Tim's guidance, I changed the code in CopyFrom() to treat the procs and
binding names as a pair and also removed the constructor for GenericDetails
that took a vector of procs, since it wasn't used anywhere.

flang/include/flang/Semantics/symbol.h

private:
   }
   bool Is(OtherKind) const;
 };
 
 // A generic interface or type-bound generic.
 class GenericDetails {
 public:
   GenericDetails() {}
-  GenericDetails(const SymbolVector &specificProcs);
 
   GenericKind kind() const { return kind_; }
   void set_kind(GenericKind kind) { kind_ = kind; }
 
   const SymbolVector &specificProcs() const { return specificProcs_; }
   const std::vector<SourceName> &bindingNames() const { return bindingNames_; }
   void AddSpecificProc(const Symbol &, SourceName bindingName);
 

flang/lib/Semantics/symbol.cpp

UseErrorDetails::UseErrorDetails(const UseDetails &useDetails) {
   add_occurrence(useDetails.location(), *GetUsedModule(useDetails).scope());
 }
 UseErrorDetails &UseErrorDetails::add_occurrence(
     const SourceName &location, const Scope &module) {
   occurrences_.push_back(std::make_pair(location, &module));
   return *this;
 }
 
-GenericDetails::GenericDetails(const SymbolVector &specificProcs)
-    : specificProcs_{specificProcs} {}
-
 void GenericDetails::AddSpecificProc(
     const Symbol &proc, SourceName bindingName) {
   specificProcs_.push_back(proc);
   bindingNames_.push_back(bindingName);
 }
 void GenericDetails::set_specific(Symbol &specific) {
   CHECK(!specific_);
   CHECK(!derivedType_);
if (specific_) {
     }
     return specific_;
   } else {
     return nullptr;
   }
 }
 
 void GenericDetails::CopyFrom(const GenericDetails &from) {
+  CHECK(specificProcs_.size() == bindingNames_.size());
+  CHECK(from.specificProcs_.size() == from.bindingNames_.size());
   if (from.specific_) {
     CHECK(!specific_ || specific_ == from.specific_);
     specific_ = from.specific_;
   }
   if (from.derivedType_) {
     CHECK(!derivedType_ || derivedType_ == from.derivedType_);
     derivedType_ = from.derivedType_;
   }
-  for (const Symbol &symbol : from.specificProcs_) {
+  for (std::size_t i{0}; i < from.specificProcs_.size(); ++i) {
     if (std::find_if(specificProcs_.begin(), specificProcs_.end(),
-            [&](const Symbol &mySymbol) { return &mySymbol == &symbol; }) ==
-        specificProcs_.end()) {
-      specificProcs_.push_back(symbol);
+            [&](const Symbol &mySymbol) {
+              return &mySymbol == &*from.specificProcs_[i];
+            }) == specificProcs_.end()) {
+      specificProcs_.push_back(from.specificProcs_[i]);
+      bindingNames_.push_back(from.bindingNames_[i]);
     }
   }
 }
 
 // The name of the kind of details for this symbol.
 // This is primarily for debugging.
 std::string DetailsToString(const Details &details) {
   return std::visit(
       common::visitors{
           [](const UnknownDetails &) { return "Unknown"; },
           [](const MainProgramDetails &) { return "MainProgram"; },
           [](const ModuleDetails &) { return "Module"; },
           [](const SubprogramDetails &) { return "Subprogram"; },
           [](const SubprogramNameDetails &) { return "SubprogramName"; },
           [](const EntityDetails &) { return "Entity"; },
           [](const ObjectEntityDetails &) { return "ObjectEntity"; },
           [](const ProcEntityDetails &) { return "ProcEntity"; },
           [](const DerivedTypeDetails &) { return "DerivedType"; },

flang/test/Semantics/resolve53.f90

contains
   end
   integer function f2(i, j)
     integer :: i, j
   end
   integer function f3(i, j)
     integer :: i, j
   end
 end
+
+module m20
+  interface operator(.not.)
+    real function f(x)
+      character(*),intent(in) :: x
+    end function
+  end interface
+  interface operator(+)
+    procedure f
+  end interface
+end module
+
+subroutine s1()
+  use m20
+  interface operator(.not.)
+    !ERROR: Procedure 'f' is already specified in generic 'operator(.not.)'
+    procedure f
+  end interface
+  interface operator(+)
+    !ERROR: Procedure 'f' is already specified in generic 'operator(+)'
+    procedure f
+  end interface
+end subroutine s1