[flang] Add nested scoping to label distinctness checking

[klausler]

Summary

Fortran defines derived type definitions and explicit interface
blocks for subroutines and functions to be nestable scopes for
statement labels, even though such labels are useless for all
purposes. Handle these scopes in label resolution so that bogus
errors about conflicting labels in "real" code don't come out.

Note that BLOCK constructs could have also been defined as scopes
for statement labeling, but were not.

flang/lib/Semantics/resolve-labels.cpp

public:
   }
 
   // C1414
   void Post(const parser::BlockData &blockData) {
     CheckOptionalName<parser::BlockDataStmt>("BLOCK DATA subprogram", blockData,
         std::get<parser::Statement<parser::EndBlockDataStmt>>(blockData.t));
   }
 
+  bool Pre(const parser::InterfaceBody &) {
+    PushDisposableMap();
+    return true;
+  }
+  void Post(const parser::InterfaceBody &) { PopDisposableMap(); }
+
   // C1564
   void Post(const parser::InterfaceBody::Function &func) {
     CheckOptionalName<parser::FunctionStmt>("FUNCTION", func,
         std::get<parser::Statement<parser::EndFunctionStmt>>(func.t));
   }
 
   // C1564
   void Post(const parser::FunctionSubprogram &functionSubprogram) {
public:
   void Post(const parser::SubroutineSubprogram &subroutineSubprogram) {
     CheckOptionalName<parser::SubroutineStmt>("SUBROUTINE",
         subroutineSubprogram,
         std::get<parser::Statement<parser::EndSubroutineStmt>>(
             subroutineSubprogram.t));
   }
 
   // C739
+  bool Pre(const parser::DerivedTypeDef &) {
+    PushDisposableMap();
+    return true;
+  }
   void Post(const parser::DerivedTypeDef &derivedTypeDef) {
     CheckOptionalName<parser::DerivedTypeStmt>("derived type definition",
         derivedTypeDef,
         std::get<parser::Statement<parser::EndTypeStmt>>(derivedTypeDef.t));
+    PopDisposableMap();
   }
 
   void Post(const parser::LabelDoStmt &labelDoStmt) {
     AddLabelReferenceFromDoStmt(std::get<parser::Label>(labelDoStmt.t));
   }
   void Post(const parser::GotoStmt &gotoStmt) { AddLabelReference(gotoStmt.v); }
   void Post(const parser::ComputedGotoStmt &computedGotoStmt) {
     AddLabelReference(std::get<std::list<parser::Label>>(computedGotoStmt.t));
void CheckLabelInRange(parser::Label label) {
     }
   }
 
   // 6.2.5., paragraph 2
   void AddTargetLabelDefinition(parser::Label label,
       LabeledStmtClassificationSet labeledStmtClassificationSet,
       ProxyForScope scope, bool isExecutableConstructEndStmt = false) {
     CheckLabelInRange(label);
-    const auto pair{programUnits_.back().targetStmts.emplace(label,
+    TargetStmtMap &targetStmtMap{disposableMaps_.empty()
+            ? programUnits_.back().targetStmts
+            : disposableMaps_.back()};
+    const auto pair{targetStmtMap.emplace(label,
         LabeledStatementInfoTuplePOD{scope, currentPosition_,
             labeledStmtClassificationSet, isExecutableConstructEndStmt})};
     if (!pair.second) {
       context_.Say(currentPosition_, "Label '%u' is not distinct"_err_en_US,
           SayLabel(label));
     }
   }
 
private:
   }
 
   void AddLabelReference(const std::list<parser::Label> &labels) {
     for (const parser::Label &label : labels) {
       AddLabelReference(label);
     }
   }
 
+  void PushDisposableMap() { disposableMaps_.emplace_back(); }
+  void PopDisposableMap() { disposableMaps_.pop_back(); }
+
   std::vector<UnitAnalysis> programUnits_;
   SemanticsContext &context_;
   parser::CharBlock currentPosition_;
   ProxyForScope currentScope_;
   std::vector<std::string> constructNames_;
+  // For labels in derived type definitions and procedure
+  // interfaces, which are their own inclusive scopes.  None
+  // of these labels can be used as a branch target, but they
+  // should be pairwise distinct.
+  std::vector<TargetStmtMap> disposableMaps_;
 };
 
 bool InInclusiveScope(const std::vector<ScopeInfo> &scopes, ProxyForScope tail,
     ProxyForScope head) {
   for (; tail != head; tail = scopes[tail].parent) {
     if (!HasScope(tail)) {
       return false;
     }

flang/test/Semantics/label17.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+1 program main
+1  type one
+2    real x
+3  end type one
+1  type two
+2    real x
+     !ERROR: Label '2' is not distinct
+2    real y
+3  end type two
+2  interface
+2   subroutine sub1(p, q)
+3    interface
+3     subroutine p
+4     end subroutine
+3     subroutine q
+4     end subroutine
+4    end interface
+5   end subroutine
+2   subroutine sub2(p, q)
+3    interface
+3     subroutine p
+4     end subroutine
+3     subroutine q
+4     end subroutine
+4    end interface
+5   end subroutine
+3  end interface
+4  call sub3
+5 contains
+1  subroutine sub3
+2   continue
+3   block
+     !ERROR: Label '2' is not distinct
+2    continue
+4   end block
+5  end subroutine
+6 end program