[flang] Don't implicitly host-associate unknown EQUIVALENCE designators

[klausler]

Summary

When resolving names in a specification part, unknown names that appear
in a specification expression before any local declaration are assumed
to be implicitly declared objects in the host scope. Objects in
EQUIVALENCE sets are not part of specification expressions, so ensure
that they do not receive this treatment; besides being wrong and
unimplementable, it will lead to a later crash during offset assignment.

flang/lib/Semantics/resolve-names.cpp

 // is implicitly typed. Because specification parts are processed before
 // execution parts, this may be the first time we see the symbol. It can't be a
 // local in the current scope (because it's in a specification expression) so
 // either it is implicitly declared in the host procedure or it is an error.
 // We create a symbol in the host assuming it is the former; if that proves to
 // be wrong we report an error later in CheckDeclarations().
 bool DeclarationVisitor::CheckForHostAssociatedImplicit(
     const parser::Name &name) {
-  if (!inSpecificationPart_) {
+  if (!inSpecificationPart_ || inEquivalenceStmt_) {
     return false;
   }
   if (name.symbol) {
     ApplyImplicitRules(*name.symbol, true);
   }
   Symbol *hostSymbol;
   Scope *host{GetHostProcedure()};
   if (!host || isImplicitNoneType(*host)) {

flang/test/Semantics/offsets03.f90

 subroutine mc         !CHECK: Subprogram scope: mc size=12 alignment=1
   character(10) :: c1 !CHECK: c1 size=10 offset=0:
   character(5)  :: c2 !CHECK: c2 size=5 offset=7:
   equivalence(c1(9:), c2(2:4))
 end
 
 ! Common block: objects are in order from COMMON statement and not part of module
 module md                   !CHECK: Module scope: md size=1 alignment=1
-  integer(1) :: i 
+  integer(1) :: i
   integer(2) :: d1          !CHECK: d1, PUBLIC size=2 offset=8:
   integer(4) :: d2          !CHECK: d2, PUBLIC size=4 offset=4:
   integer(1) :: d3          !CHECK: d3, PUBLIC size=1 offset=0:
   real(2) :: d4             !CHECK: d4, PUBLIC size=2 offset=0:
   common /common1/ d3,d2,d1 !CHECK: common1 size=10 offset=0: CommonBlockDetails alignment=4:
   common /common2/ d4       !CHECK: common2 size=2 offset=0: CommonBlockDetails alignment=2:
 end
 
module me
   integer :: i5, j5, l5(10)
   equivalence(l5(1), i5)
   common /common7/ j5, i5   ! CHECK: common7 size=44 offset=0: CommonBlockDetails alignment=4:
 
   real :: a1, a2, a3(2)
   equivalence(a1,a3(1)),(a2,a3(2))
   common /common8/ a1, a2   ! CHECK: common8 size=8 offset=0: CommonBlockDetails alignment=4:
 end
+
+! Ensure EQUIVALENCE of undeclared names in internal subprogram doesn't
+! attempt to host-associate
+subroutine host1
+ contains
+  subroutine internal
+    common /b/ x(4)  ! CHECK: x (Implicit) size=16 offset=0: ObjectEntity type: REAL(4) shape: 1_8:4_8
+    equivalence(x,y) ! CHECK: y (Implicit) size=4 offset=0: ObjectEntity type: REAL(4)
+  end
+end