[flang] Distinguish error/warning cases for bad jumps into constructs

[klausler]

Summary

Previously, jumps to labels in constructs from exterior statements
would elicit only a warning. Upgrade these to errors unless the
branch into the construct would enter into only DO, IF, and SELECT CASE
constructs, whose interiors don't scope variables or have other
set-up/tear-down semantics. Branches into these "safe" constructs
are still errors if they're nested in an unsafe construct that doesn't
also enclose the exterior branch statement.

[schweitz]

LGTM.

flang/lib/Semantics/resolve-labels.cpp

ENUM_CLASS(
     TargetStatementEnum, Do, Branch, Format, CompatibleDo, CompatibleBranch)
 using LabeledStmtClassificationSet =
     common::EnumSet<TargetStatementEnum, TargetStatementEnum_enumSize>;
 
 using IndexList = std::vector<std::pair<parser::CharBlock, parser::CharBlock>>;
 // A ProxyForScope is an integral proxy for a Fortran scope. This is required
 // because the parse tree does not actually have the scopes required.
 using ProxyForScope = unsigned;
+// Minimal scope information
+struct ScopeInfo {
+  ProxyForScope parent{};
+  bool isExteriorGotoFatal{false};
+  int depth{0};
+};
 struct LabeledStatementInfoTuplePOD {
   ProxyForScope proxyForScope;
   parser::CharBlock parserCharBlock;
   LabeledStmtClassificationSet labeledStmtClassificationSet;
   bool isExecutableConstructEndStmt;
 };
 using TargetStmtMap = std::map<parser::Label, LabeledStatementInfoTuplePOD>;
 struct SourceStatementInfoTuplePOD {
constexpr LabeledStmtClassificationSet ConstructBranchTargetFlags(
   return labeledStmtClassificationSet;
 }
 
 static unsigned SayLabel(parser::Label label) {
   return static_cast<unsigned>(label);
 }
 
 struct UnitAnalysis {
-  UnitAnalysis() { scopeModel.push_back(0); }
+  UnitAnalysis() { scopeModel.emplace_back(); }
 
   SourceStmtList doStmtSources;
   SourceStmtList formatStmtSources;
   SourceStmtList otherStmtSources;
   SourceStmtList assignStmtSources;
   TargetStmtMap targetStmts;
-  std::vector<ProxyForScope> scopeModel;
+  std::vector<ScopeInfo> scopeModel;
 };
 
 // Some parse tree record for statements simply wrap construct names;
 // others include them as tuple components.  Given a statement,
 // return a pointer to its name if it has one.
 template <typename A>
 const parser::CharBlock *GetStmtName(const parser::Statement<A> &stmt) {
   const std::optional<parser::Name> *name{nullptr};
public:
   }
 
   const std::vector<UnitAnalysis> &ProgramUnits() const {
     return programUnits_;
   }
   SemanticsContext &ErrorHandler() { return context_; }
 
 private:
-  bool PushSubscope() {
-    programUnits_.back().scopeModel.push_back(currentScope_);
-    currentScope_ = programUnits_.back().scopeModel.size() - 1;
-    return true;
+  ScopeInfo &PushScope() {
+    auto &model{programUnits_.back().scopeModel};
+    int newDepth{model.empty() ? 1 : model[currentScope_].depth + 1};
+    ScopeInfo &result{model.emplace_back()};
+    result.parent = currentScope_;
+    result.depth = newDepth;
+    currentScope_ = model.size() - 1;
+    return result;
   }
   bool InitializeNewScopeContext() {
     programUnits_.emplace_back(UnitAnalysis{});
     currentScope_ = 0u;
-    return PushSubscope();
+    PushScope();
+    return true;
   }
-  void PopScope() {
-    currentScope_ = programUnits_.back().scopeModel[currentScope_];
+  ScopeInfo &PopScope() {
+    ScopeInfo &result{programUnits_.back().scopeModel[currentScope_]};
+    currentScope_ = result.parent;
+    return result;
   }
   ProxyForScope ParentScope() {
-    return programUnits_.back().scopeModel[currentScope_];
+    return programUnits_.back().scopeModel[currentScope_].parent;
   }
   bool SwitchToNewScope() {
-    PopScope();
-    return PushSubscope();
+    ScopeInfo &oldScope{PopScope()};
+    bool isExteriorGotoFatal{oldScope.isExteriorGotoFatal};
+    PushScope().isExteriorGotoFatal = isExteriorGotoFatal;
+    return true;
   }
 
   template <typename A> bool PushConstructName(const A &a) {
     const auto &optionalName{std::get<0>(std::get<0>(a.t).statement.t)};
     if (optionalName) {
       constructNames_.emplace_back(optionalName->ToString());
     }
-    return PushSubscope();
+    // Gotos into this construct from outside it are diagnosed, and
+    // are fatal unless the construct is a DO, IF, or SELECT CASE.
+    PushScope().isExteriorGotoFatal =
+        !(std::is_same_v<A, parser::DoConstruct> ||
+            std::is_same_v<A, parser::IfConstruct> ||
+            std::is_same_v<A, parser::CaseConstruct>);
+    return true;
   }
   bool PushConstructName(const parser::BlockConstruct &blockConstruct) {
     const auto &optionalName{
         std::get<parser::Statement<parser::BlockStmt>>(blockConstruct.t)
             .statement.v};
     if (optionalName) {
       constructNames_.emplace_back(optionalName->ToString());
     }
-    return PushSubscope();
+    PushScope().isExteriorGotoFatal = true;
+    return true;
   }
   template <typename A> void PopConstructNameIfPresent(const A &a) {
     const auto &optionalName{std::get<0>(std::get<0>(a.t).statement.t)};
     if (optionalName) {
       constructNames_.pop_back();
     }
   }
   void PopConstructNameIfPresent(const parser::BlockConstruct &blockConstruct) {
private:
 
   std::vector<UnitAnalysis> programUnits_;
   SemanticsContext &context_;
   parser::CharBlock currentPosition_;
   ProxyForScope currentScope_;
   std::vector<std::string> constructNames_;
 };
 
-bool InInclusiveScope(const std::vector<ProxyForScope> &scopes,
-    ProxyForScope tail, ProxyForScope head) {
-  for (; tail != head; tail = scopes[tail]) {
+bool InInclusiveScope(const std::vector<ScopeInfo> &scopes, ProxyForScope tail,
+    ProxyForScope head) {
+  for (; tail != head; tail = scopes[tail].parent) {
     if (!HasScope(tail)) {
       return false;
     }
   }
   return true;
 }
 
 ParseTreeAnalyzer LabelAnalysis(
if (maxPosition && parser::IsDecimalDigit(position[0])) {
     for (; (i < maxPosition) && std::isspace(position[i]); ++i) {
     }
     return parser::CharBlock{position.begin() + i, position.end()};
   }
   return position;
 }
 
 ProxyForScope ParentScope(
-    const std::vector<ProxyForScope> &scopes, ProxyForScope scope) {
-  return scopes[scope];
+    const std::vector<ScopeInfo> &scopes, ProxyForScope scope) {
+  return scopes[scope].parent;
 }
 
 void CheckLabelDoConstraints(const SourceStmtList &dos,
     const SourceStmtList &branches, const TargetStmtMap &labels,
-    const std::vector<ProxyForScope> &scopes, SemanticsContext &context) {
+    const std::vector<ScopeInfo> &scopes, SemanticsContext &context) {
   IndexList loopBodies;
   for (const auto &stmt : dos) {
     const auto &label{stmt.parserLabel};
     const auto &scope{stmt.proxyForScope};
     const auto &position{stmt.parserCharBlock};
     auto doTarget{GetLabel(labels, label)};
     if (!HasScope(doTarget.proxyForScope)) {
       // C1133
void CheckLabelDoConstraints(const SourceStmtList &dos,
   }
 
   CheckBranchesIntoDoBody(branches, labels, loopBodies, context);
   CheckDoNesting(loopBodies, context);
 }
 
 // 6.2.5
 void CheckScopeConstraints(const SourceStmtList &stmts,
-    const TargetStmtMap &labels, const std::vector<ProxyForScope> &scopes,
+    const TargetStmtMap &labels, const std::vector<ScopeInfo> &scopes,
     SemanticsContext &context) {
   for (const auto &stmt : stmts) {
     const auto &label{stmt.parserLabel};
     const auto &scope{stmt.proxyForScope};
     const auto &position{stmt.parserCharBlock};
     auto target{GetLabel(labels, label)};
     if (!HasScope(target.proxyForScope)) {
       context.Say(
           position, "Label '%u' was not found"_err_en_US, SayLabel(label));
     } else if (!InInclusiveScope(scopes, scope, target.proxyForScope)) {
       // Clause 11.1.2.1 prohibits transfer of control to the interior of a
       // block from outside the block, but this does not apply to formats.
       // C1038 and C1034 forbid statements in FORALL and WHERE constructs
       // (resp.) from being branch targets.
       if (target.labeledStmtClassificationSet.test(
               TargetStatementEnum::Format)) {
         continue;
       }
+      bool isFatal{false};
+      ProxyForScope fromScope{scope};
+      for (ProxyForScope toScope{target.proxyForScope}; fromScope != toScope;
+           toScope = scopes[toScope].parent) {
+        if (scopes[toScope].isExteriorGotoFatal) {
+          isFatal = true;
+          break;
+        }
+        if (scopes[toScope].depth == scopes[fromScope].depth) {
+          fromScope = scopes[fromScope].parent;
+        }
+      }
       context.Say(position,
-          "Label '%u' is in a construct that prevents its use as a branch target here"_en_US,
+          isFatal
+              ? "Label '%u' is in a construct that prevents its use as a branch target here"_err_en_US
+              : "Label '%u' is in a construct that prevents its use as a branch target here"_en_US,
           SayLabel(label));
     }
   }
 }
 
 void CheckBranchTargetConstraints(const SourceStmtList &stmts,
     const TargetStmtMap &labels, SemanticsContext &context) {
   for (const auto &stmt : stmts) {
if (HasScope(branchTarget.proxyForScope)) {
             .Attach(stmt.parserCharBlock, "Control flow use of '%u'"_en_US,
                 SayLabel(label));
       }
     }
   }
 }
 
 void CheckBranchConstraints(const SourceStmtList &branches,
-    const TargetStmtMap &labels, const std::vector<ProxyForScope> &scopes,
+    const TargetStmtMap &labels, const std::vector<ScopeInfo> &scopes,
     SemanticsContext &context) {
   CheckScopeConstraints(branches, labels, scopes, context);
   CheckBranchTargetConstraints(branches, labels, context);
 }
 
 void CheckDataXferTargetConstraints(const SourceStmtList &stmts,
     const TargetStmtMap &labels, SemanticsContext &context) {
   for (const auto &stmt : stmts) {
     const auto &label{stmt.parserLabel};
     auto ioTarget{GetLabel(labels, label)};
     if (HasScope(ioTarget.proxyForScope)) {
       if (!ioTarget.labeledStmtClassificationSet.test(
               TargetStatementEnum::Format)) {
         context
             .Say(ioTarget.parserCharBlock, "'%u' not a FORMAT"_err_en_US,
                 SayLabel(label))
             .Attach(stmt.parserCharBlock, "data transfer use of '%u'"_en_US,
                 SayLabel(label));
       }
     }
   }
 }
 
 void CheckDataTransferConstraints(const SourceStmtList &dataTransfers,
-    const TargetStmtMap &labels, const std::vector<ProxyForScope> &scopes,
+    const TargetStmtMap &labels, const std::vector<ScopeInfo> &scopes,
     SemanticsContext &context) {
   CheckScopeConstraints(dataTransfers, labels, scopes, context);
   CheckDataXferTargetConstraints(dataTransfers, labels, context);
 }
 
 void CheckAssignTargetConstraints(const SourceStmtList &stmts,
     const TargetStmtMap &labels, SemanticsContext &context) {
   for (const auto &stmt : stmts) {
if (HasScope(target.proxyForScope) &&
               SayLabel(label))
           .Attach(stmt.parserCharBlock, "ASSIGN statement use of '%u'"_en_US,
               SayLabel(label));
     }
   }
 }
 
 void CheckAssignConstraints(const SourceStmtList &assigns,
-    const TargetStmtMap &labels, const std::vector<ProxyForScope> &scopes,
+    const TargetStmtMap &labels, const std::vector<ScopeInfo> &scopes,
     SemanticsContext &context) {
   CheckScopeConstraints(assigns, labels, scopes, context);
   CheckAssignTargetConstraints(assigns, labels, context);
 }
 
 bool CheckConstraints(ParseTreeAnalyzer &&parseTreeAnalysis) {
   auto &context{parseTreeAnalysis.ErrorHandler()};
   for (const auto &programUnit : parseTreeAnalysis.ProgramUnits()) {

flang/test/Semantics/label05.f90

 ! RUN: not %flang_fc1 -fdebug-unparse-with-symbols %s 2>&1 | FileCheck %s
 ! CHECK: Label '50' was not found
+! CHECK-NOT: error: Label '55' is in a construct that prevents its use as a branch target here
 ! CHECK: Label '55' is in a construct that prevents its use as a branch target here
 ! CHECK: Label '70' is not a branch target
 ! CHECK: Control flow use of '70'
-! CHECK: Label '80' is in a construct that prevents its use as a branch target here
-! CHECK: Label '90' is in a construct that prevents its use as a branch target here
-! CHECK: Label '91' is in a construct that prevents its use as a branch target here
-! CHECK: Label '92' is in a construct that prevents its use as a branch target here
+! CHECK: error: Label '80' is in a construct that prevents its use as a branch target here
+! CHECK: error: Label '90' is in a construct that prevents its use as a branch target here
+! CHECK: error: Label '91' is in a construct that prevents its use as a branch target here
+! CHECK: error: Label '92' is in a construct that prevents its use as a branch target here
 
 subroutine sub00(a,b,n,m)
   real a(n,m)
   real b(n,m)
   if (n .ne. m) then
      goto 50
   end if
 6 n = m

flang/test/Semantics/label14.f90

 ! Tests implemented for this standard
-! 11.1.4 - 4 It is permissible to branch to and end-block-stmt only withinh its
+! 11.1.4 - 4 It is permissible to branch to an end-block-stmt only within its
 !            Block Construct
 
-! RUN: %flang_fc1 -fsyntax-only %s 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -fsyntax-only %s 2>&1 | FileCheck %s
 ! CHECK: Label '20' is in a construct that prevents its use as a branch target here
 
 subroutine s1
   block
     goto (10) 1
 10  end block
 
   block