diff --git a/flang/lib/semantics/GetValue.def b/flang/lib/semantics/GetValue.def
deleted file mode 100644
index 9e2b3b95569e..000000000000
--- a/flang/lib/semantics/GetValue.def
+++ /dev/null
@@ -1,148 +0,0 @@
-
-// ============ Forward declarations ==============
-
-template <typename T> inline const auto & GET_VALUE( const T &x) ;
-template <typename T> inline auto & GET_VALUE(  T &x) ;
-template <typename T> inline bool HAS_VALUE( const T &x) ;
-template <typename T> inline bool HAS_VALUE(  T &x) ;
-
-#ifndef IGNORE_Scalar
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Scalar<T> &x) ;
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Scalar<T> &x) ;
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Scalar<T> &x) ;
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Scalar<T> &x) ;
-#endif
-
-#ifndef IGNORE_Constant
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Constant<T> &x) ;
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Constant<T> &x) ;
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Constant<T> &x) ;
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Constant<T> &x) ;
-#endif
-
-#ifndef IGNORE_Integer
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Integer<T> &x) ;
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Integer<T> &x) ;
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Integer<T> &x) ;
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Integer<T> &x) ;
-#endif
-
-#ifndef IGNORE_Logical
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Logical<T> &x) ;
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Logical<T> &x) ;
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Logical<T> &x) ;
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Logical<T> &x) ;
-#endif
-
-#ifndef IGNORE_DefaultChar
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::DefaultChar<T> &x) ;
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::DefaultChar<T> &x) ;
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::DefaultChar<T> &x) ;
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::DefaultChar<T> &x) ;
-#endif
-
-#ifndef IGNORE_Indirection
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Indirection<T> &x) ;
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Indirection<T> &x) ;
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Indirection<T> &x) ;
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Indirection<T> &x) ;
-#endif
-
-#ifndef IGNORE_Statement
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Statement<T> &x) ;
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Statement<T> &x) ;
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Statement<T> &x) ;
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Statement<T> &x) ;
-#endif
-
-#ifndef IGNORE_optional
-template <typename T> inline const auto & GET_VALUE( const std::optional<T> &x)  ;
-template <typename T> inline auto & GET_VALUE(  std::optional<T> &x) ;
-template <typename T> inline bool HAS_VALUE( const std::optional<T> &x) ;
-template <typename T> inline bool HAS_VALUE(  std::optional<T> &x) ;
-#endif
-
-
-// =========== Actual implementation of GET_VALUE() and HAS_VALUE() ==============================
-
-
-template <typename T> inline const auto & GET_VALUE( const T &x) { return x ;}
-template <typename T> inline auto & GET_VALUE(  T &x) { return x ;}
-template <typename T> inline bool HAS_VALUE( const T &x) { return true; }
-template <typename T> inline bool HAS_VALUE(  T &x) { return true; }
-
-#ifndef IGNORE_Scalar
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Scalar<T> &x) { return GET_VALUE(x.thing) ;}
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Scalar<T> &x) { return GET_VALUE(x.thing) ;}
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Scalar<T> &x) { return HAS_VALUE(x.thing)  ;}
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Scalar<T> &x) { return HAS_VALUE(x.thing)  ;}
-#endif
-
-#ifndef IGNORE_Constant
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Constant<T> &x) { return GET_VALUE(x.thing) ;}
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Constant<T> &x) { return GET_VALUE(x.thing) ;}
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Constant<T> &x) { return HAS_VALUE(x.thing)  ;}
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Constant<T> &x) { return HAS_VALUE(x.thing)  ;}
-#endif
-
-#ifndef IGNORE_Integer
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Integer<T> &x) { return GET_VALUE(x.thing) ;}
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Integer<T> &x) { return GET_VALUE(x.thing) ;}
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Integer<T> &x) { return HAS_VALUE(x.thing)  ;}
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Integer<T> &x) { return HAS_VALUE(x.thing)  ;}
-#endif
-
-#ifndef IGNORE_Logical
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Logical<T> &x) { return GET_VALUE(x.thing) ;}
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Logical<T> &x) { return GET_VALUE(x.thing) ;}
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Logical<T> &x) { return HAS_VALUE(x.thing)  ;}
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Logical<T> &x) { return HAS_VALUE(x.thing)  ;}
-#endif
-
-#ifndef IGNORE_DefaultChar
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::DefaultChar<T> &x) { return GET_VALUE(x.thing) ;}
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::DefaultChar<T> &x) { return GET_VALUE(x.thing) ;}
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::DefaultChar<T> &x) { return HAS_VALUE(x.thing)  ;}
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::DefaultChar<T> &x) { return HAS_VALUE(x.thing)  ;}
-#endif
-
-#ifndef IGNORE_Indirection
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Indirection<T> &x) { return GET_VALUE(*x) ;}
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Indirection<T> &x) { return GET_VALUE(*x) ;}
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Indirection<T> &x) { return GET_VALUE(*x) ;}
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Indirection<T> &x) { return GET_VALUE(*x) ;}
-#endif
-
-#ifndef IGNORE_Statement
-template <typename T> inline const auto & GET_VALUE( const Fortran::parser::Statement<T> &x) { return GET_VALUE(x.statement) ;}
-template <typename T> inline auto & GET_VALUE(  Fortran::parser::Statement<T> &x) { return GET_VALUE(x.statement) ;}
-template <typename T> inline bool HAS_VALUE( const Fortran::parser::Statement<T> &x) { return HAS_VALUE(x.statement) ;}
-template <typename T> inline bool HAS_VALUE(  Fortran::parser::Statement<T> &x) { return HAS_VALUE(x.statement) ;}
-#endif
-
-#ifndef IGNORE_optional
-template <typename T> inline const auto & GET_VALUE( const std::optional<T> &x)  { return GET_VALUE(x.value()) ; } 
-template <typename T> inline auto & GET_VALUE(  std::optional<T> &x) { return GET_VALUE(x.value()) ; } 
-template <typename T> inline bool HAS_VALUE( const std::optional<T> &x) { return x.has_value() && HAS_VALUE(*x); } 
-template <typename T> inline bool HAS_VALUE(  std::optional<T> &x) { return x.has_value() && HAS_VALUE(*x); } 
-#endif
-
-template <typename T> inline auto GET_OPT_VALUE(const T &x) { 
-  if ( HAS_VALUE(x) ) {
-    return & GET_VALUE(x) ;
-  } else {
-    return decltype(&GET_VALUE(x)){0} ;
-  }
-}
-
-template <typename T> inline auto GET_OPT_VALUE(T &x) { 
-  if ( HAS_VALUE(x) ) {
-    return & GET_VALUE(x) ;
-  } else {
-    return decltype(&GET_VALUE(x)){0} ;
-  }
-}
-
-#undef GET_VALUE
-#undef HAS_VALUE
-#undef GET_OPT_VALUE
diff --git a/flang/lib/semantics/GetValue.h b/flang/lib/semantics/GetValue.h
deleted file mode 100644
index 2d86e7227f26..000000000000
--- a/flang/lib/semantics/GetValue.h
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef FORTRAN_SEMANTICS_GETVALUE_H_
-#define FORTRAN_SEMANTICS_GETVALUE_H_
-
-#undef IGNORE_optional
-#undef IGNORE_Statement
-#undef IGNORE_Scalar
-#undef IGNORE_Constant
-#undef IGNORE_Indirection
-#undef IGNORE_Logical
-#undef IGNORE_DefaultChar
-
-// Each include of "GetValue.def" provides a set of helper functions
-// whose names are specified by the macros GET_VALUE, HAS_VALUE and 
-// GET_OPT_VALUE.
-//
-// The purpose of those function is to provide easier access to the
-// parse-tree by ignoring some wrapper classes/
-//
-//
-// GET_VALUE(x) provides a reference to the value that x is holding.
-//
-// The following wrapper classes are ignored unless the corresponding
-// IGNORES_xxx macro is defined. 
-//
-//    Scalar<T>
-//    Constant<T>
-//    Integer<T>
-//    Logical<T>
-//    DefaultChar<T>
-//    Indirection<T>
-//    Statement<T>
-//    std::optional<T>
-//
-//
-// HAS_VALUE(x) return true if it is legal to call GET_VALUE(x) in case x 
-// contains some std::optional<T>  
-//
-// Example:
-//   Constant<std::optional<Indirection<std::optional<int>>>> &x = ... ;
-//   if ( HasValue(x) ) {
-//     const int &v = getValue(x) ; 
-//     ... 
-//   } 
-// 
-// GET_OPT_VALUE(T &x) is equivalent to
-//
-//    HAS_VALUE(x) ? &GET_VALUE(x) : (Type*) nullptr
-//
-// here Type is the type of GET_VALUE(x) 
-//
-// Example:  
-//
-//  const Scalar<optional<Integer<Expr>>> & z = ... 
-//  const Expr *ptr_z = GET_OPT_VALUE(z) ; 
-//  if ( ptr_z ) {
-//    ... do something with *ptr_z %
-//  }
-//
-
-// This is the default version that handles all wrapper
-
-#define GET_VALUE GetValue
-#define HAS_VALUE HasValue
-#define GET_OPT_VALUE GetOptValue
-#include "GetValue.def"
-
-// HAS_VALUE and GET_OPT_VALUE are only interesting when
-// std::optional is not ignored. 
-// We need to give a name to the function but they are pretty much useless
-#define IGNORE_optional
-#define GET_VALUE GetOptionalValue
-#define HAS_VALUE HasOptionalValue__
-#define GET_OPT_VALUE GetOptValue__
-#include "GetValue.def"
-#undef IGNORE_optional
-
-#define IGNORE_Statement
-#define GET_VALUE GetStatementValue
-#define HAS_VALUE HasStatementValue
-#define GET_OPT_VALUE GetOptStatementValue
-#include "GetValue.def"
-#undef IGNORE_Statement
-
-#define IGNORE_Scalar
-#define GET_VALUE GetScalarValue
-#define HAS_VALUE HasScalarValue
-#define GET_OPT_VALUE GetOptScalarValue
-#include "GetValue.def"
-#undef IGNORE_Scalar
-
-#define IGNORE_Constant
-#define GET_VALUE GetConstantValue
-#define HAS_VALUE HasConstantValue
-#define GET_OPT_VALUE GetOptConstantValue
-#include "GetValue.def"
-#undef IGNORE_Constant
-
-#define IGNORE_Indirection
-#define GET_VALUE GetIndirectionValue
-#define HAS_VALUE HasIndirectionValue
-#define GET_OPT_VALUE GetOptIndirectionValue
-#include "GetValue.def"
-#undef IGNORE_Indirection
-
-
-#define IGNORE_Logical
-#define GET_VALUE GetLogicalValue
-#define HAS_VALUE HasLogicalValue
-#define GET_OPT_VALUE GetOptLogicalValue
-#include "GetValue.def"
-#undef IGNORE_Logical
-
-#define IGNORE_DefaultChar
-#define GET_VALUE GetDefaultCharValue
-#define HAS_VALUE HasDefaultCharValue
-#define GET_OPT_VALUE GetOptDefaultCharValue
-#include "GetValue.def"
-#undef IGNORE_DefaultChar
-
-#endif  // FORTRAN_SEMANTICS_GETVALUE_H_
diff --git a/flang/lib/semantics/LabelTable.h b/flang/lib/semantics/LabelTable.h
deleted file mode 100644
index 1cbe2764da87..000000000000
--- a/flang/lib/semantics/LabelTable.h
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef FORTRAN_SEMANTICS_LABELTABLE_H_
-#define FORTRAN_SEMANTICS_LABELTABLE_H_
-
-#include <cassert>
-#include <stack>
-
-namespace Fortran::semantics {
-
-// Each statement label is in one of those groups    
-enum class LabelGroup
-{
-  BranchTarget, ///< A label a possible branch target
-  Format,       ///< A label on a FORMAT statement
-  Other         ///< A label on another statement  
-};
-
-  
-//
-// Hold all the labels of a Program Unit 
-//
-// This is going to a integrated into the Scope/SymbolTable
-// once we have it implemented. For now, I am just simulating
-// scopes with LabelTable and LabelTableStack
-//
-class LabelTable 
-{
-private:
-  
-  struct Entry {
-    // TODO: what to put here
-  Fortran::parser::Provenance loc; 
-  }; 
-
-  std::map<int,Entry> entries_ ;
-  
-public:
-  
-  void add( int label , Fortran::parser::Provenance loc ) 
-  { 
-    if (label<1 || label>99999) return ; // Hoops! 
-    auto &entry = entries_[label] ;
-    entry.loc = loc ; 
-  }
-
-  bool find(int label, Fortran::parser::Provenance &loc)
-  {
-    
-    auto it = entries_.find(label);
-    if( it != entries_.end()) {
-      Entry & entry{it->second}; 
-      loc = entry.loc; 
-      return true; 
-    }
-    return false;
-  }
-
-
-}; // of class LabelTable
-
-
-class LabelTableStack {
-private:
-  std::stack<LabelTable*> stack ; 
-public:
-  LabelTable *PushLabelTable( LabelTable *table ) 
-  {
-    assert(table!=NULL);
-    stack.push(table);
-    return table; 
-  }
-
-  void PopLabelTable( LabelTable *table ) 
-  {
-    assert( !stack.empty() ) ;
-    assert( stack.top() == table ) ;
-    stack.pop(); 
-  }
-
-  LabelTable & GetLabelTable() {
-    assert( !stack.empty() ) ;
-    return *stack.top() ;
-  }
-  
-  bool NoLabelTable() {
-    return stack.empty() ; 
-  }
-
-}; // of class LabelTableStack
-
-} // of namespace Fortran::semantics
-
-#endif  // FORTRAN_SEMANTICS_LABELTABLE_H_
diff --git a/flang/lib/semantics/SemanticData.h b/flang/lib/semantics/SemanticData.h
deleted file mode 100644
index dfa90ed0ab31..000000000000
--- a/flang/lib/semantics/SemanticData.h
+++ /dev/null
@@ -1,608 +0,0 @@
-// Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef FORTRAN_SEMANTICS_SEMANTICDATA_H_
-#define FORTRAN_SEMANTICS_SEMANTICDATA_H_
-
-#include <cassert> 
-
-//
-// 
-// Declare here the members of the Semantic<T> that will 
-// be attached to each parse-tree class T. The default is 
-// an empty struct. All members added here shall be 
-// copiable and should be provided with a default value.  
-//
-// Here are a few common fields 
-//  
-//  Scope *scope_provider  = the scope provided by a construct or statement
-//  int stmt_index         = the index used in the StatementMap 
-//
-// Remark: Weither we want to annotate parse-tree nodes with 
-// semantic information is still debatable. 
-//
-
-namespace Fortran::semantics {
-
-// Initialize the semantic information attached to a parser-tree node
-//
-// Ideally, the function should be called once at the begining of the corresponding Pre() 
-// member in Pass1. However, for the few cases where the semantic data need to be 
-// initialize earlier the strict argument can be set to false. 
-//
-template <typename T>  Semantic<T> & InitSema(const T &node, bool strict=true) { 
-
-  // Do not use the default implementation!
-  // If the following assert fails, then a DECLARE_SEMANTIC_DATA is 
-  // missing below
-  assert(Semantic<T>::IS_DECLARED);
-
-  if (node.s) {
-    if (strict) {
-      // TODO: emit proper message
-      std::cerr << "Duplicate call of " << __PRETTY_FUNCTION__ << "\n" ;
-      exit(1);
-    } else {
-      return *(node.s); 
-    }
-  }
-  auto s = new Semantic<T>( const_cast<T*>(&node) ) ;
-  const_cast<T&>(node).s = s; 
-  return *s ; 
-} 
-
-
-// Retreive the semantic information attached to a parser-tree node
-template <typename T> Semantic<T> & GetSema(const T &node) { 
-  // Do not use the default implementation!
-  // If the following assert fails, then a DECLARE_SEMANTIC is missing above 
-  assert(Semantic<T>::IS_DECLARED); 
-  assert(node.s) ;
-  return *(node.s) ;
-} 
-
-
-#define DEFINE_SEMANTIC_DATA(Class) \
-  template <> struct Semantic<Fortran::parser::Class> { \
-    Semantic<Fortran::parser::Class>(Fortran::parser::Class *node) {} \
-    enum {IS_DECLARED=1};
-  
-#define END_SEMANTIC_DATA \
-  }
-
-// Some fields that need to be defined for all statements
-#define SEMANTIC_STMT_FIELDS \
-   int stmt_index=0 
-
-DEFINE_SEMANTIC_DATA(ProgramUnit)
-  StatementMap *statement_map=0 ;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(MainProgram)
-  Scope *scope_provider=0 ; 
-  LabelTable *label_table=0 ; 
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SubroutineSubprogram)
-  Scope *scope_provider=0 ; 
-  LabelTable *label_table=0 ; 
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(FunctionSubprogram)
-  Scope *scope_provider=0 ; 
-  LabelTable *label_table=0 ; 
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(Module)
-  Scope *scope_provider=0 ; 
-  LabelTable *label_table=0 ; 
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(DerivedTypeDef)
-  // WARNING: there is also a sm::DerivedTypeDef defined in types.h 
-  Scope *scope_provider=0 ;
-END_SEMANTIC_DATA;
-
-
-DEFINE_SEMANTIC_DATA(AssignmentStmt)
-  SEMANTIC_STMT_FIELDS; 
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(DataStmt)
-  SEMANTIC_STMT_FIELDS; 
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(FunctionStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SubroutineStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ModuleStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-  
-DEFINE_SEMANTIC_DATA(EndModuleStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-  
-DEFINE_SEMANTIC_DATA(StmtFunctionStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndFunctionStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndSubroutineStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(TypeDeclarationStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(DerivedTypeStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndTypeStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(PrintStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(UseStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ProgramStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndProgramStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ImplicitStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(AccessStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(AllocatableStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(AsynchronousStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(BindStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(CodimensionStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ContiguousStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ContainsStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(DimensionStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ExternalStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(IntentStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(IntrinsicStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(NamelistStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(OptionalStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(PointerStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ProtectedStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SaveStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(TargetStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ValueStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(VolatileStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(CommonStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EquivalenceStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(BasedPointerStmt) // extension
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(GenericStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ParameterStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EnumDef)
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EnumDefStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndEnumStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(InterfaceStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndInterfaceStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(IfThenStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ElseIfStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-  
-DEFINE_SEMANTIC_DATA(ElseStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-  
-DEFINE_SEMANTIC_DATA(EndIfStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(IfStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SelectCaseStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(CaseStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndSelectStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SelectRankStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SelectRankCaseStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SelectTypeStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ProcedureDeclarationStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(StructureStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(StructureDef::EndStructureStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(FormatStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EntryStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ImportStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(AllocateStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(BackspaceStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(CallStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(CloseStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ContinueStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(DeallocateStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndfileStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EventPostStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EventWaitStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(CycleStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ExitStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(FailImageStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(FlushStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(FormTeamStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(GotoStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(InquireStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(LockStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(NullifyStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(OpenStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(PointerAssignmentStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ReadStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ReturnStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(RewindStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(StopStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SyncAllStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SyncImagesStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SyncMemoryStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(SyncTeamStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(UnlockStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(WaitStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(WhereStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(WriteStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ComputedGotoStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ForallStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
- 
-DEFINE_SEMANTIC_DATA(ForallConstructStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndForallStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
- 
-DEFINE_SEMANTIC_DATA(ArithmeticIfStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(AssignStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(AssignedGotoStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(PauseStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(PrivateStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(TypeBoundProcedureStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(TypeBoundGenericStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(FinalProcedureStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ComponentDefStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EnumeratorDefStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(TypeGuardStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(NonLabelDoStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(LabelDoStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndDoStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(BlockStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndBlockStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(AssociateStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndAssociateStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(ChangeTeamStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndChangeTeamStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(CriticalStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-DEFINE_SEMANTIC_DATA(EndCriticalStmt)
-  SEMANTIC_STMT_FIELDS;
-END_SEMANTIC_DATA;
-
-
-#undef DEFINE_SEMANTIC_DATA
-#undef END_SEMANTIC_DATA_SEMANTIC
-#undef SEMANTIC_STMT_FIELDS
-
-} // of namespace Fortran::semantics
-
-#endif  // FORTRAN_SEMANTICS_SEMANTICDATA_H_
diff --git a/flang/lib/semantics/StatementMap.cc b/flang/lib/semantics/StatementMap.cc
deleted file mode 100644
index 07b77dc7120e..000000000000
--- a/flang/lib/semantics/StatementMap.cc
+++ /dev/null
@@ -1,622 +0,0 @@
-// Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-
-#include "StatementMap.h"
-
-#include <cassert>
-#include <cstdlib>
-#include <iomanip>
-#include <iostream>
-
-#define FAIL(msg) \
-  do { \
-    std::cerr << "FATAL " << __FILE__ << ":" << __LINE__ << ":\n   " << msg \
-              << "\n"; \
-    exit(1); \
-  } while (0)
-#define INTERNAL_ERROR FAIL("Internal Error")
-
-namespace Fortran::semantics {
-
-StatementMap::Entry &StatementMap::at(Index index) {
-  if (!(( First() <= index) && (index <= Last()))) {
-    FAIL("Illegal Stmt index " << index << " (expect " 
-         << First() << " .." << Last() << ")");
-    exit(1);
-  }
-  return entries_[index - 1];
-}
-
-const StatementMap::Entry &StatementMap::at(Index index) const {
-  if (!((First() <= index) && (index <= Last()))) {
-    FAIL("Illegal Stmt index " << index << " (expect " 
-         << First() << ".." << Last() << ")");
-    exit(1);
-  }
-  return entries_[index - 1];
-}
-
-StatementMap::Index StatementMap::Add(StmtClass sclass, int label) {
-  Entry self;
-  self.sclass = sclass;
-  self.group = StmtClassToGroup(sclass);
-  self.label = label;
-
-  self.parent = None;
-  self.prev_in_body = None;
-  self.next_in_body = None;
-  self.prev_in_construct = None;
-  self.next_in_construct = None;
-
-  Index self_index = Last() + 1;
-
-  if (Size() == 0) {
-    // Special case of the first entry.
-    entries_.push_back(self);
-    return self_index;
-  }
-
-  Index prev_index = self_index - 1;
-  auto prev_group = at(prev_index).group;
-  if (prev_group == StmtGroup::End) {
-    // When inserting after a closed construct, do as if
-    // that was after a single statement
-    prev_index = StartOfConstruct(prev_index);
-    prev_group = StmtGroup::Single;
-  }
-
-  Entry &prev = at(prev_index);
-
-  if (self.group == StmtGroup::Single || self.group == StmtGroup::Start) {
-    if (prev_group == StmtGroup::Start || prev_group == StmtGroup::Part) {
-      // Insert 'self' as first statement in body of 'prev;
-      self.parent = prev_index;
-    } else if (prev_group == StmtGroup::Single) {
-      // Insert 'self' after 'prev' (in the same body)
-      prev.next_in_body = self_index;
-      self.prev_in_body = prev_index;
-      self.parent = prev.parent;
-    } else {
-      INTERNAL_ERROR;
-    }
-  } else if (self.group == StmtGroup::Part || self.group == StmtGroup::End) {
-    if (prev_group == StmtGroup::Start || prev_group == StmtGroup::Part) {
-      // Close the empty body of 'prev'
-      assert(prev.next_in_construct == None);
-      prev.next_in_construct = self_index;
-      self.prev_in_construct = prev_index;
-    } else if (prev_group == StmtGroup::Single) {
-      // Close a non-empty body ending with 'prev'
-      assert(prev.next_in_body == None);
-      if (prev.parent == None) {
-        DumpFlat(std::cerr);
-      }
-      assert(prev.parent != None);
-      at(prev.parent).next_in_construct = self_index;
-      self.prev_in_construct = prev.parent;
-    } else {
-      INTERNAL_ERROR;
-    }
-  }
-
-  // TODO: Beware of the reallocation cost of calling push_back() for each
-  // statement.
-  // const int chunksize = 128;
-  // entries_.reserve( (entries_.size()/chunksize+1)*chunksize );
-
-  entries_.push_back(self);
-
-
-  if ( self.group == StmtGroup::Part || self.group == StmtGroup::End ) {
-    assert( self.prev_in_construct != None) ;
-    assert( NextInConstruct(self.prev_in_construct) == self_index) ;
-    assert( PrevInConstruct(self_index) == self.prev_in_construct) ;
-    AssertNextInConstruct(self.prev_in_construct);
-  }
-
-  return self_index;
-}
-
-//
-// 'prev_index' shall be a Start or Part statement.
-//
-// Assert that the next statement in the construct is of an expected class.
-//
-//
-void StatementMap::AssertNextInConstruct(Index prev_index) const {
-
-  if (prev_index == None) return;  
-  auto &prev = at(prev_index);
-  if (prev.next_in_construct == None) return;
-  auto &next = at(prev.next_in_construct);
-
-
-#define ORDER(A, B) (prev.sclass == StmtClass::A && next.sclass == StmtClass::B)
-
-  if (  // If THEN ... [ELSEIF]* ... [ELSE] ... Endif
-      ORDER(IfThen, ElseIf) || ORDER(IfThen, Else) || ORDER(IfThen, EndIf) ||
-      ORDER(ElseIf, ElseIf) || ORDER(ElseIf, Else) || ORDER(ElseIf, EndIf) ||
-      ORDER(Else, EndIf) ||
-      // PROGRAM ... [CONTAINS] ... END
-      ORDER(Program, Contains) || ORDER(Program, EndProgram) ||
-      ORDER(Contains, EndProgram) ||
-      // MODULE
-      ORDER(Module, Contains) || ORDER(Module, EndModule) ||
-      ORDER(Contains, EndModule) ||
-      // SUBROUTINE
-      ORDER(Subroutine, Contains) || ORDER(Subroutine, EndSubroutine) ||
-      ORDER(Contains, EndSubroutine) ||
-      // FUNCTION
-      ORDER(Function, Contains) || ORDER(Function, EndFunction) ||
-      ORDER(Contains, EndFunction) ||
-      // IF ..
-      ORDER(If, DummyEndIf) ||
-      // FORALL ..
-      ORDER(Forall, DummyEndForall) || ORDER(ForallConstruct, EndForall) ||
-      // WHERE ..
-      ORDER(Where, DummyEndWhere) || ORDER(WhereConstruct, MaskedElsewhere) ||
-      ORDER(WhereConstruct, EndWhere) || ORDER(ElseWhere, EndWhere) ||
-      ORDER(MaskedElsewhere, EndWhere) ||
-      ORDER(MaskedElsewhere, MaskedElsewhere) ||
-      // ASSOCIATE
-      ORDER(Associate, EndAssociate) ||
-      // BLOCK
-      ORDER(Block, EndBlock) ||
-      // CHANGE TEAM
-      ORDER(ChangeTeam, EndChangeTeam) ||
-      // CRITICAL
-      ORDER(Critical, EndCritical) ||
-      // TYPE
-      ORDER(DerivedType, EndType) ||
-      // ENUM
-      ORDER(EnumDef, EndEnum) ||
-      // INTERFACE
-      ORDER(Interface, EndInterface) ||
-      // DO var=...
-      ORDER(NonLabelDo, EndDo) ||
-      // DO WHILE ...
-      ORDER(NonLabelDoWhile, EndDo) ||
-      // DO CONCURRENT
-      ORDER(NonLabelDoConcurrent, EndDo) ||
-      // DO <label> var=....
-      ORDER(LabelDo, EndDo) ||
-      ORDER(LabelDo, DummyEndDo) ||
-      // DO <label> WHILE ...
-      ORDER(LabelDoWhile, EndDo) ||
-      ORDER(LabelDoWhile, DummyEndDo) ||
-      // DO <label> CONCURRENT ...
-      ORDER(LabelDoConcurrent, EndDo) ||
-      ORDER(LabelDoConcurrent, DummyEndDo) ||
-     // SELECT CASE
-      ORDER(SelectCase, EndSelect) || ORDER(SelectCase, Case) ||
-      ORDER(Case, Case) || ORDER(Case, EndSelect) ||
-      ORDER(SelectCase, CaseDefault) || ORDER(CaseDefault, Case) ||
-      ORDER(Case, CaseDefault) || ORDER(CaseDefault, CaseDefault) ||
-      ORDER(CaseDefault, EndSelect) ||
-
-      // SELECT RANK
-      ORDER(SelectRank, EndSelect) || ORDER(SelectRank, SelectRankCase) ||
-      ORDER(SelectRank, SelectRankStar) || ORDER(SelectRank, SelectRankDefault) ||
-      
-      ORDER(SelectRankCase, SelectRankCase) || ORDER(SelectRankCase, SelectRankStar) ||
-      ORDER(SelectRankCase, SelectRankDefault) || ORDER(SelectRankCase, EndSelect) ||
-
-      ORDER(SelectRankStar, SelectRankCase) || ORDER(SelectRankStar, SelectRankStar) ||
-      ORDER(SelectRankStar, SelectRankDefault) || ORDER(SelectRankStar, EndSelect) ||
-
-      ORDER(SelectRankDefault, SelectRankCase) || ORDER(SelectRankDefault, SelectRankStar) ||
-      ORDER(SelectRankDefault, SelectRankDefault) ||ORDER(SelectRankDefault, EndSelect) ||
-
-      // SELECT TYPE
-      ORDER(SelectType, EndSelect) || ORDER(SelectType, TypeGuard) || 
-      ORDER(SelectType, ClassGuard) ||  ORDER(SelectType, ClassDefault) || 
-      
-      ORDER(TypeGuard, EndSelect) || ORDER(TypeGuard, TypeGuard) || 
-      ORDER(TypeGuard, ClassGuard) ||  ORDER(TypeGuard, ClassDefault) || 
-
-      ORDER(ClassGuard, EndSelect) || ORDER(ClassGuard, TypeGuard) || 
-      ORDER(ClassGuard, ClassGuard) ||  ORDER(ClassGuard, ClassDefault) || 
-
-      ORDER(ClassDefault, EndSelect) || ORDER(ClassDefault, TypeGuard) || 
-      ORDER(ClassDefault, ClassGuard) ||  ORDER(ClassDefault, ClassDefault) || 
-      
-      // STRUCTURE (PGI)
-      ORDER(Structure, EndStructure)) {
-    // That looks good
-  } else {
-    // Todo: print location of both statement
-    FAIL("Found " << StmtClassName(next.sclass) << " after "
-                  << StmtClassName(prev.sclass));
-  }
-#undef ORDER
-}
-
-// Provide the number of statements in the map.
-// Reminder: the proper indices are 1..Size()
-int StatementMap::Size() const { return entries_.size(); }
-
-//
-// Specialize the StmtClass of an existing statement.
-//
-//
-void StatementMap::Specialize( Index index, StmtClass oldc, StmtClass newc) {
-  Entry &self = at(index);
-  
-  if (self.sclass != oldc) {
-    INTERNAL_ERROR;
-  }
-  if (self.group != StmtClassToGroup(oldc)) {
-    INTERNAL_ERROR;
-  }
-  if (self.group != StmtClassToGroup(newc)) {
-    INTERNAL_ERROR;
-  }
-
-  // Only a few specializations are allowed
-  if ((oldc == StmtClass::Case && newc == StmtClass::CaseDefault) ||
-      (oldc == StmtClass::TypeGuard && newc == StmtClass::ClassDefault) ||
-      (oldc == StmtClass::TypeGuard && newc == StmtClass::ClassGuard) ||
-      (oldc == StmtClass::SelectRankCase && newc == StmtClass::SelectRankStar) ||
-      (oldc == StmtClass::SelectRankCase && newc == StmtClass::SelectRankDefault) ||
-      (oldc == StmtClass::Access && newc == StmtClass::PublicAccess) ||
-      (oldc == StmtClass::Access && newc == StmtClass::PrivateAccess) || 
-      (oldc == StmtClass::LabelDo && newc == StmtClass::LabelDoWhile)|| 
-      (oldc == StmtClass::LabelDo && newc == StmtClass::LabelDoConcurrent) || 
-      (oldc == StmtClass::NonLabelDo && newc == StmtClass::NonLabelDoWhile) || 
-      (oldc == StmtClass::NonLabelDo && newc == StmtClass::NonLabelDoConcurrent)) {
-    self.sclass = newc;
-
-    // Paranoid mode! More consistency checks
-    AssertNextInConstruct(self.prev_in_construct);
-    AssertNextInConstruct(index);
-
-  } else {
-    INTERNAL_ERROR;
-  }
-}
-
-void StatementMap::DumpFlat(std::ostream &out, bool verbose) const {
-  for (Index i = First() ; i <= Last(); i++) {
-    out << std::setw(4) << std::right << i << ": ";
-    DumpStmt(out, i, verbose);
-  }
-}
-
-void StatementMap::DumpBody(
-    std::ostream &out, Index index, bool rec, int level, bool verbose) const {
-  for (Index i = FirstInBody(index); i != None; i = Next(i)) {
-    Dump(out, i, rec, level, verbose);
-  }
-}
-
-void StatementMap::DumpStmt(
-    std::ostream &out, Index index, bool verbose) const {
-  const auto &stmt = at(index);
-
-  switch (stmt.group) {
-  case StmtGroup::Single: out << "| "; break;
-  case StmtGroup::Start: out << "> "; break;
-  case StmtGroup::Part: out << "+ "; break;
-  case StmtGroup::End: out << "< "; break;
-  }
-
-  out << StmtClassName(stmt.sclass);
-
-  if (verbose) {
-    // Enable this while debugging the Map
-    if (stmt.parent) out << " parent=" << stmt.parent;
-    if (stmt.prev_in_body) out << " prev_in_body=" << stmt.prev_in_body;
-    if (stmt.next_in_body) out << " next_in_body=" << stmt.next_in_body;
-    if (stmt.prev_in_construct)
-      out << " prev_in_construct=" << stmt.prev_in_construct;
-    if (stmt.next_in_construct)
-      out << " next_in_construct=" << stmt.next_in_construct;
-  }
-  out << "\n";
-}
-
-void StatementMap::Dump(
-    std::ostream &out, Index index, bool rec, int level, bool verbose) const {
-  while (index != None) {
-    const auto &stmt = at(index);
-    out << std::setw(4) << std::right << index << ": ";
-
-    for (int i = 0; i < level; i++)
-      out << "|  ";
-
-    DumpStmt(out, index, verbose);
-
-    if (rec &&
-        (stmt.group == StmtGroup::Start || stmt.group == StmtGroup::Part)) {
-      DumpBody(out, index, rec, level + 1, verbose);
-      index = NextInConstruct(index);
-    } else {
-      index = None;
-    }
-  }
-}
-
-void StatementMap::CheckIndex(Index index) const {
-  assert(index > 0 && index < int(entries_.size()));
-}
-
-StatementMap::Index StatementMap::Next(Index index) const {
-  auto &e = at(index);
-  if (e.group == StmtGroup::Single) {
-    return e.next_in_body;
-  } else if (e.group == StmtGroup::Start) {
-    return e.next_in_body;
-  } else {
-    INTERNAL_ERROR;
-    return None;
-  }
-}
-
-StatementMap::Index StatementMap::Prev(Index index) const {
-  auto &e = at(index);
-  if (e.group == StmtGroup::Single) {
-    return e.prev_in_body;
-  } else if (e.group == StmtGroup::Start) {
-    return e.prev_in_body;
-  } else {
-    INTERNAL_ERROR;
-    return None;
-  }
-}
-
-bool StatementMap::EmptyBody(Index index) const {
-  auto &e = at(index);
-  if (e.group == StmtGroup::Start) {
-    if (e.next_in_construct == None) {
-      // The body construction is not finished yet
-      INTERNAL_ERROR;
-      return None;
-    } else {
-      return (e.next_in_construct == index + 1);
-    }
-  } else if (e.group == StmtGroup::Part) {
-    if (e.next_in_construct == None) {
-      // The body construction is not finished yet
-      INTERNAL_ERROR;
-      return None;
-    }
-    return (e.next_in_construct == index + 1);
-  } else {
-    INTERNAL_ERROR;
-    return None;
-  }
-}
-
-StatementMap::Index StatementMap::FirstInBody(StatementMap::Index index) const {
-  auto &e = at(index);
-  if (e.group == StmtGroup::Start) {
-    if (e.next_in_construct == index + 1)
-      return None;  // an empty body
-    else
-      return index + 1;
-  } else if (e.group == StmtGroup::Part) {
-    if (e.next_in_construct == index + 1)
-      return None;  // an empty body
-    else
-      return index + 1;
-  } else {
-    INTERNAL_ERROR;
-    return None;
-  }
-}
-
-StatementMap::Index StatementMap::LastInBody(StatementMap::Index index) const {
-  CheckIndex(index);
-  auto &stmt = at(index);
-  if (stmt.group == StmtGroup::Start) {
-    if (stmt.next_in_construct == index + 1) {
-      return None;  //  empty body
-    } else if (stmt.next_in_construct == None) {
-      // We are probably querying an incomplete construct
-      INTERNAL_ERROR;
-      return None;
-    } else {
-      return LastInPreviousBody(stmt.next_in_construct);
-    }
-  } else if (stmt.group == StmtGroup::Part) {
-    if (stmt.next_in_construct == index + 1) {
-      return None;  // empty body
-    } else if (stmt.next_in_construct == None) {
-      // We are probably querying an incomplete construct
-      INTERNAL_ERROR;
-      return None;
-    } else {
-      return LastInPreviousBody(stmt.next_in_construct);
-    }
-  } else {
-    INTERNAL_ERROR;
-    return None;
-  }
-}
-
-// Functionnally equivalent to LastInBody(PreviousPartOfConstruct(index))
-StatementMap::Index StatementMap::LastInPreviousBody(
-    StatementMap::Index index) const {
-  auto &stmt = at(index);
-  if (stmt.group == StmtGroup::Part || stmt.group == StmtGroup::End) {
-    auto &prev = at(index - 1);
-    if (prev.group == StmtGroup::Single) {
-      return index - 1;
-    } else if (prev.group == StmtGroup::End) {
-      return StartOfConstruct(index - 1);
-    } else if (prev.group == StmtGroup::Start) {
-      return None;
-    } else if (prev.group == StmtGroup::Part) {
-      return None;
-    } else {
-      INTERNAL_ERROR;
-      return None;
-    }
-  } else {
-    INTERNAL_ERROR;
-    return None;
-  }
-}
-
-StatementMap::Index StatementMap::FindPrevInConstruct(
-    StatementMap::Index index, StmtClass sclass) const {
-  while (true) {
-    index = PrevInConstruct(index);
-    if (index == None) return None;
-    if (at(index).sclass == sclass) return index;
-  }
-}
-
-StatementMap::Index StatementMap::FindNextInConstruct(
-    StatementMap::Index index, StmtClass sclass) const {
-  while (true) {
-    index = NextInConstruct(index);
-    if (index == None) return None;
-    if (at(index).sclass == sclass) return index;
-  }
-}
-
-StatementMap::Index StatementMap::PrevInConstruct(
-    StatementMap::Index index) const {
-  auto &stmt = at(index);
-  if (stmt.group == StmtGroup::Start) {
-    return None;
-  } else if (stmt.group == StmtGroup::Part) {
-    return stmt.prev_in_construct;
-  } else if (stmt.group == StmtGroup::End) {
-    return stmt.prev_in_construct;
-  } else {
-    INTERNAL_ERROR;
-    return None;
-  }
-}
-
-StatementMap::Index StatementMap::NextInConstruct(
-    StatementMap::Index index) const {
-  auto &stmt = at(index);
-  if (stmt.group == StmtGroup::Start) {
-    return stmt.next_in_construct;
-  } else if (stmt.group == StmtGroup::Part) {
-    return stmt.next_in_construct;
-  } else if (stmt.group == StmtGroup::End) {
-    return None;
-  } else {
-    INTERNAL_ERROR;
-    return None;
-  }
-}
-
-// Find the Start component of a construct specified by
-// any of its component.
-StatementMap::Index StatementMap::StartOfConstruct(
-    StatementMap::Index index) const {
-  auto &stmt = at(index);
-  if (stmt.group == StmtGroup::Start) {
-    return index;
-  } else if (stmt.group == StmtGroup::Part || stmt.group == StmtGroup::End) {
-    return StartOfConstruct(stmt.prev_in_construct);
-  } else {
-    INTERNAL_ERROR;
-    return None;
-  }
-}
-
-// Find the End component of a construct specified by
-// any of its component.
-StatementMap::Index StatementMap::EndOfConstruct(
-    StatementMap::Index index) const {
-  while (true) {
-    auto &stmt = at(index);
-    if (stmt.group == StmtGroup::Start || stmt.group == StmtGroup::Part) {
-      index = stmt.next_in_construct;
-    } else if (stmt.group == StmtGroup::End) {
-      return index;
-    } else {
-      INTERNAL_ERROR;
-      return None;
-    }
-  }
-}
-
-// Find the last component of a construct.
-//
-// Unlike EndOfConstruct(), this visitor does not require the presence of
-// any End construct and so can be safely used during the creation of
-// the statement map
-//
-StatementMap::Index StatementMap::LastOfConstruct(
-    StatementMap::Index index) const {
-  while (true) {
-    auto &stmt = at(index);
-    if (stmt.group == StmtGroup::Start || stmt.group == StmtGroup::Part) {
-      if (stmt.next_in_construct == None)
-        return index;  // end of an incomplete construct
-      index = stmt.next_in_construct;
-    } else if (stmt.group == StmtGroup::End) {
-      return index;  // end of an complete construct
-    } else {
-      INTERNAL_ERROR;
-      return None;
-    }
-  }
-}
-
-// Visit all the statements that compose a construct.
-//
-// 'stmt' shall be a construct component (so in group Start, Part or End)
-void StatementMap::VisitConstruct(
-    StatementMap::Index stmt, std::function<bool(Index)> action) const {
-  Index start = StartOfConstruct(stmt);
-  for (Index at = start; at != None; at = NextInConstruct(at)) {
-    if (!action(at)) break;
-  }
-}
-
-// Visit all the statements that compose a construct in reverse order.
-//
-// 'stmt' shall be a construct component (so in group Start, Part or End)
-//
-void StatementMap::VisitConstructRev(
-    Index stmt, std::function<bool(Index)> action) const {
-  // Reminder: Using LastOfConstruct instead of EndOfConstruct
-  //           because the visitor shall usable while constructing
-  //           the statement map.
-  std::cerr << "#" << stmt;
-  Index start = LastOfConstruct(stmt);
-  std::cerr << "%" << start;
-  for (Index at = start; at != None; at = PrevInConstruct(at)) {
-    std::cerr << "@" << at;
-    if (!action(at)) break;
-  }
-}
-
-// // Set the label required to close a LabelDo
-// void StatementMap::SetLabelDoLabel(Index do_stmt, int label) {
-//   assert(at(do_stmt).sclass == StmtClass::LabelDo);
-//   assert(label != 0);
-//   label_do_map_[do_stmt] = label;
-// }
-
-// int StatementMap::GetLabelDoLabel(Index do_stmt) const {
-//   auto it = label_do_map_.find(do_stmt);
-//   if (it != label_do_map_.end()) {
-//     return it->second;
-//   }
-//   // In theory that should never happen
-//   INTERNAL_ERROR;
-//   return 0;
-// }
-
-}  // namespace Fortran::semantics
diff --git a/flang/lib/semantics/StatementMap.h b/flang/lib/semantics/StatementMap.h
deleted file mode 100644
index 8dce381b249b..000000000000
--- a/flang/lib/semantics/StatementMap.h
+++ /dev/null
@@ -1,242 +0,0 @@
-// Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef FORTRAN_SEMANTICS_STATEMENTMAP_H_
-#define FORTRAN_SEMANTICS_STATEMENTMAP_H_
-
-#include "Stmt.h"
-#include <functional>
-#include <map>
-#include <vector>
-
-namespace Fortran::semantics {
-
-
-//
-// A StatementMap describes the relations between statements in a program unit
-// and also hold information that are common to each statement (label, provenance,
-// ...)
-//
-// In the parse-tree each struct representing a statement (see Stmt.def)
-// is associated with an index in the statement map.
-//
-// Valid indices are 1 to Size().
-//
-// The index None=0 represents no statement.
-//
-// In the map, each statement belong to one of 4 groups Single,
-// Start, Part, and End (see Stmt.def)
-//
-// Also, the statements are stored in 2 dimensions:
-//  - the body dimension for Single and Start statements.
-//  - the construct dimension for Start, Part and End statements
-//
-// In the construct dimension, a sequence of statement is always
-// composed of one Start, any number of Part and one End.
-//
-// Only Start and Part statements can have a body and they are
-// the 'parent' of each statement in that body.
-//
-// The mapping of Fortran statements to the 4 groups Single, Start,
-// Part, and End should be obvious.
-//
-// For instance, consider the following piece of code
-//
-//   DO i=1,n
-//      PRINT *, "in DO body"
-//      IF (i==1) THEN
-//        PRINT *, "in IF body"
-//        CYCLE
-//      ELSE IF (i==2)
-//        PRINT *, "in ELSE IF body"
-//      ELSE
-//        PRINT *, "in ELSE body"
-//      ENDIF
-//      PRINT *, "also in DO body"
-//   ENDDO
-//
-// The statement map Dump() for that piece of code shall look like that
-//
-//     10:    > NonLabelDo
-//     11:    | | Print
-//     12:    | > IfThen
-//     13:    | | | Print
-//     14:    | | | Cycle
-//     15:    | + ElseIf
-//     16:    | | | Print
-//     17:    | + Else
-//     18:    | | | Print
-//     19:    | < EndIf
-//     20:    | | Print
-//     21:    < EndDo
-//
-// The '>', '+' and '>' are used to mark the Start, Part and End statements.
-//
-// In that dump, we see that:
-//  - The DO construct is comprised of statements 10 and 21
-//  - The IF construct is comprised of statements 12, 15, 17 and 19
-//  - The body of statement 10 is comprised of statements 11, 12, and 20
-//  - The body of statement 12 is comprised of statements 13 and 14
-//  - The body of statement 15 is comprised of statement 16
-//  - The body of statement 17 is comprised of statement 18
-//
-// For the few Fortran constructs that do not provide an explicit 'End'
-// statement, a dummy entry will be provided in the map. For instance,
-// the construct
-//
-//    IF (cond) CYCLE
-//
-// could dump as follow:
-//
-//    30:  > If
-//    31:  | | Cycle
-//    32:  < DummyEndIf
-//
-//
-class StatementMap {
-public:
-  typedef int Index;  // should become an opaque type.
-  
-  static constexpr Index None = 0;
-  
-private:
-  struct Entry {
-    StmtClass sclass;
-    StmtGroup group;
-    
-    int label;      // The label associated to the statement (1..99999) or 0
-    
-    // Relations to other statements.
-    Index parent;
-    Index prev_in_body;
-    Index next_in_body;
-    Index prev_in_construct;
-    Index next_in_construct;
-  };
-  
-  std::vector<Entry> entries_;
-
-  std::map<Index, int> label_do_map_;
-
-  
-  Entry &at(Index index);
-  const Entry &at(Index index) const;
-
-public:
-  // Add a statement to the map.
-  Index Add(StmtClass sclass, int label);
-
-  // Set the label required to close a LabelDo
-//  void SetLabelDoLabel(Index do_stmt, int label);
-
-//  int GetLabelDoLabel(Index do_stmt) const;
-
-  //
-  // 'prev_index' shall be a Start or Part statement.
-  //
-  // Assert that the next statement in the construct is of an expected class.
-  //
-  //
-  void AssertNextInConstruct(Index prev_index) const;
-
-  // Provide the number of statements in the map.
-  // Reminder: the proper indices are 1..Size()
-  int Size() const;
-
-  // The index of the first statement added to the map
-  Index First() const { return 1; }
-
-  // The index of the last statement  added to the map
-  Index Last() const { return Size(); }
-
-  //
-  // Specialize the StmtClass of an existing statement.
-  //
-  //
-  void Specialize(Index index, StmtClass oldclass, StmtClass newclass);
-
-  StmtClass GetClass(Index index) const { return at(index).sclass; }
-
-  StmtGroup GetGroup(Index index) const { return at(index).group; }
-
-  // Provide the numerical label associated to that statement or 0.
-  // Be aware that labels are not necessarily unique and so cannot 
-  // be used to identify a statement within the whole map.
-  int GetLabel(Index index) const { return at(index).label; }
-
-  Index GetParent(Index index) const { return at(index).parent; }
-
-
-  // Dump all the statements in the map in sequence so without
-  // relying on the statement 'hierarchy'. This is only useful
-  // to debug the statement map 'hierarchy'.
-  void DumpFlat(std::ostream &out, bool verbose = true) const;
-
-  void DumpBody(std::ostream &out, Index index, bool rec = true, int level = 0,
-                bool verbose = false) const;
-  void DumpStmt(std::ostream &out, Index index, bool verbose = false) const;
-  void Dump(std::ostream &out, Index index, bool rec = true, int level = 0,
-            bool verbose = false) const;
-  
-  void CheckIndex(Index index) const;
-  
-  Index Next(Index index) const;
-  Index Prev(Index index) const;
-  
-  bool EmptyBody(Index index) const;
-  
-  Index FirstInBody(Index index) const;
-  Index LastInBody(Index index) const;
-  
-  // Functionally equivalent to LastInBody(PreviousPartOfConstruct(index))
-  Index LastInPreviousBody(Index index) const;
-  Index FindPrevInConstruct(Index index, StmtClass sclass) const;
-  
-  Index FindNextInConstruct(Index index, StmtClass sclass) const;
-
-  Index PrevInConstruct(Index index) const;
-
-  Index NextInConstruct(Index index) const;
-
-  // Find the Start component of a construct specified by
-  // any of its component.
-  Index StartOfConstruct(Index index) const;
-
-  // Find the End component of a construct specified by
-  // any of its component.
-  Index EndOfConstruct(Index index) const;
-
-  // Find the last component of a construct.
-  //
-  // Unlike EndOfConstruct(), this visitor does not require the presence of
-  // any End construct and so can be safely used during the creation of
-  // the statement map
-  //
-  Index LastOfConstruct(Index index) const;
-
-  // Visit all the statements that compose a construct.
-  //
-  // 'stmt' shall be a construct component (so in group Start, Part or End)
-  void VisitConstruct(Index stmt, std::function<bool(Index)> action) const;
-
-  // Visit all the statements that compose a construct in reverse order.
-  //
-  // 'stmt' shall be a construct component (so in group Start, Part or End)
-  //
-  void VisitConstructRev(Index stmt, std::function<bool(Index)> action) const;
-};
-
-}  // namespace Fortran::semantics
-
-#endif  // FORTRAN_SEMANTICS_STATEMENTMAP_H_
diff --git a/flang/lib/semantics/Stmt.def b/flang/lib/semantics/Stmt.def
deleted file mode 100644
index 40315f609f23..000000000000
--- a/flang/lib/semantics/Stmt.def
+++ /dev/null
@@ -1,191 +0,0 @@
-
-//
-// DECLARE_PARSER_STMT(Name,Class,Group,Text)          
-//   - Name is the name in StmtClass enum (typically, that is 'Class' without the 'Stmt' suffix. 
-//   - Class is a parser-tree class name.
-//   - Group is any StmtGroup value so one of Single, Start, Part, End.
-//   - Text is a human readable text describing the statement and usable in
-//     a formated error message such as "error in %s statement"
-//
-// For a given Class, there should be exactly one DECLARE_PARSER_STMT
-//
-// DECLARE_PARSER_STMT_ALT(Name,Class,Group,Text)   
-//   Provide an alternative Name for a given Class.
-//   
-// DECLARE_DUMMY_STMT(Name,Group,Text)
-//   Provide a Name in StmtClass enum that does not correspond to any existing Class. 
-//
-//
-// The default implementation for those macros is to call DECLARE_STMT(Name,Class,Group,Text)
-// 
-//
-
-#ifndef DECLARE_PARSER_STMT
-#define DECLARE_PARSER_STMT(Name,Class,Group,Text) DECLARE_STMT(Name,Class,Group,Text)
-#endif
-
-#ifndef DECLARE_PARSER_STMT_ALT
-#define DECLARE_PARSER_STMT_ALT(Name,Class,Group,Text) DECLARE_STMT(Name,Class,Group,Text)
-#endif
-
-#ifndef DECLARE_DUMMY_STMT
-#define DECLARE_DUMMY_STMT(Name,Group,Text) DECLARE_STMT(Name,void,Group,Text) 
-#endif
-
-// DECLARE_FIRST_STMT is a special alias for the first occurence of DECLARE_PARSER_STMT.
-#ifndef DECLARE_FIRST_STMT
-#define DECLARE_FIRST_STMT(Name,Class,Group,Text) DECLARE_PARSER_STMT(Name,Class,Group,Text) 
-#endif
-
-DECLARE_FIRST_STMT( Access               , AccessStmt               , Single    , "PUBLIC or PRIVATE" )
-DECLARE_PARSER_STMT(Allocatable          , AllocatableStmt          , Single    , "ALLOCATABLE" )
-DECLARE_PARSER_STMT(Allocate             , AllocateStmt             , Single    , "ALLOCATE" )
-DECLARE_PARSER_STMT(ArithmeticIf         , ArithmeticIfStmt         , Single    , "arithmetic IF" )
-DECLARE_PARSER_STMT(Assign               , AssignStmt               , Single    , "ASSIGN TO" )
-DECLARE_PARSER_STMT(AssignedGoto         , AssignedGotoStmt         , Single    , "assigned GOTO" )
-DECLARE_PARSER_STMT(Assignment           , AssignmentStmt           , Single    , "assignment" )
-DECLARE_PARSER_STMT(Associate            , AssociateStmt            , Start     , "ASSOCIATE" )
-DECLARE_PARSER_STMT(Asynchronous         , AsynchronousStmt         , Single    , "ASYNCHRONOUS" )
-DECLARE_PARSER_STMT(Backspace            , BackspaceStmt            , Single    , "BACKSPACE" )
-DECLARE_PARSER_STMT(BasedPointer         , BasedPointerStmt         , Single    , "Based Pointer" )
-DECLARE_PARSER_STMT(Bind                 , BindStmt                 , Single    , "BIND" )
-DECLARE_PARSER_STMT(Block                , BlockStmt                , Start     , "BLOCK" )
-DECLARE_PARSER_STMT(Call                 , CallStmt                 , Single    , "CALL" )
-DECLARE_PARSER_STMT(Case                 , CaseStmt                 , Part      , "CASE" )
-DECLARE_PARSER_STMT(ChangeTeam           , ChangeTeamStmt           , Start     , "CHANGE TEAM" )
-DECLARE_PARSER_STMT(Close                , CloseStmt                , Single    , "CLOSE" )
-DECLARE_PARSER_STMT(Codimension          , CodimensionStmt          , Single    , "CODIMENSION" )
-DECLARE_PARSER_STMT(Common               , CommonStmt               , Single    , "COMMON" )
-DECLARE_PARSER_STMT(ComputedGoto         , ComputedGotoStmt         , Single    , "computed GOTO" )
-DECLARE_PARSER_STMT(ComponentDef         , ComponentDefStmt         , Single    , "component declaration" )
-DECLARE_PARSER_STMT(Contains             , ContainsStmt             , Part      , "CONTAINS" )
-DECLARE_PARSER_STMT(Contiguous           , ContiguousStmt           , Single    , "CONTIGUOUS" )
-DECLARE_PARSER_STMT(Continue             , ContinueStmt             , Single    , "CONTINUE" )
-DECLARE_PARSER_STMT(Critical             , CriticalStmt             , Start     , "CRITICAL" )
-DECLARE_PARSER_STMT(Cycle                , CycleStmt                , Single    , "CYCLE" )
-DECLARE_PARSER_STMT(Data                 , DataStmt                 , Single    , "DATA" )
-DECLARE_PARSER_STMT(Deallocate           , DeallocateStmt           , Single    , "DEALLOCATE" )
-DECLARE_PARSER_STMT(DerivedType          , DerivedTypeStmt          , Start     , "TYPE declaration" )
-DECLARE_PARSER_STMT(Dimension            , DimensionStmt            , Single    , "DIMENSION" )
-DECLARE_PARSER_STMT(Else                 , ElseStmt                 , Part      , "ELSE" )
-DECLARE_PARSER_STMT(ElseIf               , ElseIfStmt               , Part      , "ELSE IF" )
-DECLARE_PARSER_STMT(ElseWhere            , ElseWhereStmt            , Part      , "ELSE WHERE" )
-DECLARE_PARSER_STMT(EndAssociate         , EndAssociateStmt         , End       , "END ASSOCIATE" )
-DECLARE_PARSER_STMT(EndBlock             , EndBlockStmt             , End       , "END BLOCK" )
-DECLARE_PARSER_STMT(EndChangeTeam        , EndChangeTeamStmt        , End       , "END TEAM" )
-DECLARE_PARSER_STMT(EndCritical          , EndCriticalStmt          , End       , "END CRITICAL" )
-DECLARE_PARSER_STMT(EndDo                , EndDoStmt                , End       , "END DO" )
-DECLARE_PARSER_STMT(EndEnum              , EndEnumStmt              , End       , "END ENUM" )
-DECLARE_PARSER_STMT(EndForall            , EndForallStmt            , End       , "END FORALL" )
-DECLARE_PARSER_STMT(EndFunction          , EndFunctionStmt          , End       , "END FUNCTION" )
-DECLARE_PARSER_STMT(EndIf                , EndIfStmt                , End       , "END IF" )
-DECLARE_PARSER_STMT(EndInterface         , EndInterfaceStmt         , End       , "END INTERFACE" )
-DECLARE_PARSER_STMT(EndModule            , EndModuleStmt            , End       , "END MODULE" )
-DECLARE_PARSER_STMT(EndProgram           , EndProgramStmt           , End       , "END PROGRAM" )
-DECLARE_PARSER_STMT(EndSelect            , EndSelectStmt            , End       , "END SELECT" )
-DECLARE_PARSER_STMT(EndStructure         , EndStructureStmt         , End       , "END STRUCTURE?" )
-DECLARE_PARSER_STMT(EndSubroutine        , EndSubroutineStmt        , End       , "END SUBROUTINE" )
-DECLARE_PARSER_STMT(EndType              , EndTypeStmt              , End       , "END TYPE" )
-DECLARE_PARSER_STMT(EndWhere             , EndWhereStmt             , End       , "END WHERE" )
-DECLARE_PARSER_STMT(Endfile              , EndfileStmt              , Single    , "ENDFILE" )
-DECLARE_PARSER_STMT(Entry                , EntryStmt                , Single    , "ENTRY" )
-DECLARE_PARSER_STMT(EnumDef              , EnumDefStmt              , Start     , "ENUM" )
-DECLARE_PARSER_STMT(EnumeratorDef        , EnumeratorDefStmt        , Single    , "ENUMERATOR" )
-DECLARE_PARSER_STMT(Equivalence          , EquivalenceStmt          , Single    , "EQUIVALENCE" )
-DECLARE_PARSER_STMT(EventPost            , EventPostStmt            , Single    , "EVENT POST" )
-DECLARE_PARSER_STMT(EventWait            , EventWaitStmt            , Single    , "EVENT WAIT" )
-DECLARE_PARSER_STMT(Exit                 , ExitStmt                 , Single    , "EXIT" )
-DECLARE_PARSER_STMT(External             , ExternalStmt             , Single    , "EXTERNAL" )
-DECLARE_PARSER_STMT(FailImage            , FailImageStmt            , Single    , "FAIL IMAGE" )
-DECLARE_PARSER_STMT(FinalProcedure       , FinalProcedureStmt       , Single    , "FINAL PROCEDURE" )
-DECLARE_PARSER_STMT(Flush                , FlushStmt                , Single    , "FLUSH" )
-DECLARE_PARSER_STMT(Forall               , ForallStmt               , Start     , "FORALL" )
-DECLARE_PARSER_STMT(ForallAssignment     , ForallAssignmentStmt     , Single    , "FORALL Assignment" )
-DECLARE_PARSER_STMT(ForallConstruct      , ForallConstructStmt      , Start     , "FORALL Construct" )
-DECLARE_PARSER_STMT(FormTeam             , FormTeamStmt             , Single    , "FORM TEAM" )
-DECLARE_PARSER_STMT(Format               , FormatStmt               , Single    , "FORMAT" )
-DECLARE_PARSER_STMT(Function             , FunctionStmt             , Start     , "FUNCTION" )
-DECLARE_PARSER_STMT(Generic              , GenericStmt              , Single    , "GENERIC" )
-DECLARE_PARSER_STMT(Goto                 , GotoStmt                 , Single    , "GOTO" )
-DECLARE_PARSER_STMT(If                   , IfStmt                   , Start     , "IF" )
-DECLARE_PARSER_STMT(IfThen               , IfThenStmt               , Start     , "IF THEN" )
-DECLARE_PARSER_STMT(Implicit             , ImplicitStmt             , Single    , "IMPLICIT" )
-DECLARE_PARSER_STMT(Import               , ImportStmt               , Single    , "IMPORT" )
-DECLARE_PARSER_STMT(Inquire              , InquireStmt              , Single    , "INQUIRE" )
-DECLARE_PARSER_STMT(Intent               , IntentStmt               , Single    , "INTENT" )
-DECLARE_PARSER_STMT(Interface            , InterfaceStmt            , Start     , "INTERFACE" )
-DECLARE_PARSER_STMT(Intrinsic            , IntrinsicStmt            , Single    , "INTRINSIC" )
-DECLARE_PARSER_STMT(LabelDo              , LabelDoStmtStmt          , Start     , "label-DO " )
-DECLARE_PARSER_STMT(Lock                 , LockStmt                 , Single    , "LOCK" )
-DECLARE_PARSER_STMT(MaskedElsewhere      , MaskedElsewhereStmt      , Part      , "masked ELSE WHERE" )
-DECLARE_PARSER_STMT(Module               , ModuleStmt               , Start     , "MODULE" )
-DECLARE_PARSER_STMT(Namelist             , NamelistStmt             , Single    , "NAMELIST" )
-DECLARE_PARSER_STMT(NonLabelDo           , NonLabelDoStmtStmt       , Start     , "DO" )
-DECLARE_PARSER_STMT(Nullify              , NullifyStmt              , Single    , "NULLIFY" )
-DECLARE_PARSER_STMT(Open                 , OpenStmt                 , Single    , "OPEN" )
-DECLARE_PARSER_STMT(Optional             , OptionalStmt             , Single    , "OPTIONAL" )
-DECLARE_PARSER_STMT(Parameter            , ParameterStmt            , Single    , "PARAMETER" )
-DECLARE_PARSER_STMT(Pause                , PauseStmt                , Single    , "PAUSE" )
-DECLARE_PARSER_STMT(Pointer              , PointerStmt              , Single    , "POINTER" )
-DECLARE_PARSER_STMT(PointerAssignment    , PointerAssignmentStmt    , Single    , "pointer assignment" )
-DECLARE_PARSER_STMT(Print                , PrintStmt                , Single    , "PRINT" )
-// PrivateStmt is only used in TYPE definitions
-DECLARE_PARSER_STMT(Private              , PrivateStmt              , Single    , "PRIVATE" )
-DECLARE_PARSER_STMT(ProcedureDeclaration , ProcedureDeclarationStmt , Single    , "PROCEDURE" )
-DECLARE_PARSER_STMT(Program              , ProgramStmt              , Start     , "PROGRAM" )
-DECLARE_PARSER_STMT(Protected            , ProtectedStmt            , Single    , "PROTECTED" )
-DECLARE_PARSER_STMT(Read                 , ReadStmt                 , Single    , "READ" )
-DECLARE_PARSER_STMT(Redimension          , RedimensionStmt          , Single    , "REDIMENSION" )
-DECLARE_PARSER_STMT(Return               , ReturnStmt               , Single    , "RETURN" )
-DECLARE_PARSER_STMT(Rewind               , RewindStmt               , Single    , "REWIND" )
-DECLARE_PARSER_STMT(Save                 , SaveStmt                 , Single    , "SAVE" )
-DECLARE_PARSER_STMT(SelectCase           , SelectCaseStmt           , Start     , "SELECT CASE" )
-DECLARE_PARSER_STMT(SelectRank           , SelectRankStmt           , Start     , "SELECT RANK" )
-DECLARE_PARSER_STMT(SelectRankCase       , SelectRankCaseStmt       , Part      , "RANK" )
-DECLARE_PARSER_STMT(SelectType           , SelectTypeStmt           , Start     , "SELECT TYPE" )
-DECLARE_PARSER_STMT(Subroutine           , SubroutineStmt           , Start     , "SUBROUTINE" )
-DECLARE_PARSER_STMT(StmtFunction         , StmtFunctionStmt         , Single    , "statement-function" )
-DECLARE_PARSER_STMT(Stop                 , StopStmt                 , Single    , "STOP" )
-DECLARE_PARSER_STMT(Structure            , StructureStmt            , Start     , "STRUCTURE" )
-DECLARE_PARSER_STMT(SyncAll              , SyncAllStmt              , Single    , "SYNC ALL" )
-DECLARE_PARSER_STMT(SyncImages           , SyncImagesStmt           , Single    , "SYNC IMAGES" )
-DECLARE_PARSER_STMT(SyncMemory           , SyncMemoryStmt           , Single    , "SYNC MEMORY" )
-DECLARE_PARSER_STMT(SyncTeam             , SyncTeamStmt             , Single    , "SYNC TEAM" )
-DECLARE_PARSER_STMT(Target               , TargetStmt               , Single    , "TARGET" )
-DECLARE_PARSER_STMT(TypeBoundGeneric     , TypeBoundGenericStmt     , Single    , "type bound GENERIC" )
-DECLARE_PARSER_STMT(TypeBoundProcedure   , TypeBoundProcedureStmt   , Single    , "type bound PROCEDURE" )
-DECLARE_PARSER_STMT(TypeDeclaration      , TypeDeclarationStmt      , Single    , "declaration" )
-DECLARE_PARSER_STMT(TypeGuard            , TypeGuardStmt            , Part      , "TYPE IS" ) // See 
-DECLARE_PARSER_STMT(Unlock               , UnlockStmt               , Single    , "UNLOCK" )
-DECLARE_PARSER_STMT(Use                  , UseStmt                  , Single    , "USE" )
-DECLARE_PARSER_STMT(Value                , ValueStmt                , Single    , "VALUE" )
-DECLARE_PARSER_STMT(Volatile             , VolatileStmt             , Single    , "VOLATILE" )
-DECLARE_PARSER_STMT(Wait                 , WaitStmt                 , Single    , "WAIT" )
-DECLARE_PARSER_STMT(Where                , WhereStmt                , Start     , "WHERE" )
-DECLARE_PARSER_STMT(WhereConstruct       , WhereConstructStmt       , Start     , "WHERE construct" )
-DECLARE_PARSER_STMT(Write                , WriteStmt                , Single    , "WRITE" )
-
-
-DECLARE_PARSER_STMT_ALT(CaseDefault      , CaseStmt                 , Part      , "CASE" )
-DECLARE_PARSER_STMT_ALT(ClassDefault     , TypeGuardStmt            , Part      , "CLASS DEFAULT" )
-DECLARE_PARSER_STMT_ALT(ClassGuard       , TypeGuardStmt            , Part      , "CLASS IS" )
-DECLARE_PARSER_STMT_ALT(SelectRankStar   , SelectRankCaseStmt       , Part      , "RANK(*)" )
-DECLARE_PARSER_STMT_ALT(SelectRankDefault, SelectRankCaseStmt       , Part      , "RANK DEFAULT" )
-DECLARE_PARSER_STMT_ALT(PublicAccess     , AccessStmt               , Single    , "default PUBLIC" )
-DECLARE_PARSER_STMT_ALT(PrivateAccess    , AccessStmt               , Single    , "default PRIVATE" )
-DECLARE_PARSER_STMT_ALT(LabelDoWhile     , LabelDoStmt              , Start     , "label-DO WHILE" )
-DECLARE_PARSER_STMT_ALT(LabelDoConcurrent, LabelDoStmt              , Start     , "label-DO CONCURRENT" )
-DECLARE_PARSER_STMT_ALT(NonLabelDoWhile  , NonLabelDoStmt           , Start     , "DO " )
-DECLARE_PARSER_STMT_ALT(NonLabelDoConcurrent, NonLabelDoConcurrent  , Start     , "DO CONCURRENT" )
-
-// DummyEnd is used to provide an end to constructs that lack an explicit end statement after their body.
-DECLARE_DUMMY_STMT(DummyEndIf                                       , End       , "<DummyEndIf>" )
-DECLARE_DUMMY_STMT(DummyEndForall                                   , End       , "<DummyEndForall>" )
-DECLARE_DUMMY_STMT(DummyEndWhere                                    , End       , "<DummyEndWhere>" )
-DECLARE_DUMMY_STMT(DummyEndDo                                       , End       , "<DummyEndDo>" )
-
-#undef DECLARE_PARSER_STMT
-#undef DECLARE_PARSER_STMT_ALT
-#undef DECLARE_DUMMY_STMT
-#undef DECLARE_FIRST_STMT
-#undef DECLARE_STMT
diff --git a/flang/lib/semantics/Stmt.h b/flang/lib/semantics/Stmt.h
deleted file mode 100644
index 6767263ccb2c..000000000000
--- a/flang/lib/semantics/Stmt.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef FORTRAN_SEMANTICS_STMT_H_
-#define FORTRAN_SEMANTICS_STMT_H_
-
-#include "../parser/parse-tree.h"
-#include <variant>
-
-namespace Fortran::semantics {
-
-enum class StmtClass {
-#define DECLARE_STMT(Name, Class, Group, Text) Name,
-#include "Stmt.def"
-};
-
-enum class StmtGroup {
-  Single,  // A standalone statement
-  Start,  // A statement that starts a construct
-  Part,  // A statement that marks a part of a construct
-  End  // A statement that ends a construct
-};
-
-constexpr StmtGroup StmtClassToGroup(StmtClass sc) {
-  switch (sc) {
-#define DECLARE_STMT(Name, Class, Group, Text) \
-    case StmtClass::Name: return StmtGroup::Group; 
-
-#include "Stmt.def"
-  }
-  // Hummm... should not happen but cannot add error or assert
-  // in constexpr expression.
-  return StmtGroup::Single;
-}
-
-constexpr const char *StmtClassName(StmtClass sc) {
-  switch (sc) {
-#define DECLARE_STMT(Name, Class, Group, Text) \
-  case StmtClass::Name: return #Name;
-
-#include "Stmt.def"
-  }
-  return "????";
-}
-
-constexpr const char *StmtClassText(StmtClass sc) {
-  switch (sc) {
-#define DECLARE_STMT(Name, Class, Group, Text) \
-  case StmtClass::Name: return Text; 
-
-#include "Stmt.def"
-  }
-  return "????";
-}
-
-}  // end of namespace Fortran::semantics
-
-#endif  // FORTRAN_SEMANTICS_STMT_H_
diff --git a/flang/lib/semantics/ParseTreeDump.cc b/flang/lib/semantics/dump-parse-tree.cc
similarity index 100%
rename from flang/lib/semantics/ParseTreeDump.cc
rename to flang/lib/semantics/dump-parse-tree.cc
diff --git a/flang/lib/semantics/ParseTreeDump.h b/flang/lib/semantics/dump-parse-tree.h
similarity index 100%
rename from flang/lib/semantics/ParseTreeDump.h
rename to flang/lib/semantics/dump-parse-tree.h
diff --git a/flang/lib/semantics/pass1.cc b/flang/lib/semantics/pass1.cc
deleted file mode 100644
index 26ff8941eb9d..000000000000
--- a/flang/lib/semantics/pass1.cc
+++ /dev/null
@@ -1,2962 +0,0 @@
-// Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-
-#include "../../lib/parser/format-specification.h"
-#include "../../lib/parser/idioms.h"
-#include "../../lib/parser/indirection.h"
-#include "../../lib/parser/parse-tree-visitor.h"
-#include "../../lib/parser/parse-tree.h"
-#include "../../lib/parser/provenance.h"
-
-#include "scope.h"
-#include "StatementMap.h"
-#include "ParseTreeDump.h"
-#include "LabelTable.h"
-#include "SemanticData.h"
-#include "GetValue.h"
-
-#include <cassert>
-#include <cstdlib>
-#include <cstring>
-#include <cstddef>
-
-#include <functional>
-#include <iomanip>
-#include <iostream>
-#include <list>
-#include <map>
-#include <optional>
-#include <sstream>
-#include <stack>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-namespace psr = Fortran::parser ;
-namespace sm  = Fortran::semantics ;
-
-using sm::StmtClass;
-using sm::StmtGroup;
-using sm::GetSema;
-using sm::InitSema;
-using sm::Scope ;
-using sm::LabelTable ;
-using sm::LabelTableStack ;
-
-
-#define TODO  do { std::cerr << "NOT YET IMPLEMENTED " << __FILE__ << ":" << __LINE__ << "\n" ; exit(1) ; } while(0)
-#define CONSUME(x) do { (void)x ; } while(0) 
-
-#if 1
-#define TRACE_CALL()  do { std::cerr << "*** call " << __PRETTY_FUNCTION__ << "\n" ; } while(0)
-#else
-#define TRACE_CALL()  do {} while(0)
-#endif
-
-#define TRACE(msg) do { std::cerr << msg << "\n" ; } while(0)
-#define FAIL(msg)  do { std::cerr << "FATAL " << __FILE__ << ":" << __LINE__ << ":\n   " << msg << "\n" ; exit(1) ; } while(0)
-#define INTERNAL_ERROR FAIL("Internal Error")
-
-//
-// Make it easy to look to env variables  (for tracing & debugging)
-//
-// return true iff the env var 'name' is set and its first characters is neither '0' or 'n'
-// 
-bool ENV(const char *name) {
-  return ( getenv(name) &&  !( getenv(name)[0] == '0' || getenv(name)[0] == 'n') );
-}
-
-// A simple helper to remove 'const' without having to make the type explicit (which can be 
-// annoying since combined types can be quite long in the parse-tree)
-//
-// For example.
-//   Using std::const_cast: 
-//      auto &uses = std::const_cast<std::list<Statement<Indirection<UseStmt>>>&>(const_use_list);
-//   Using unconst:
-//      auto &uses = unconst(const_uses);
-//
-template <typename T> static inline T & unconst(const T&x) {
-  return const_cast<T&>(x) ;
-}
-
-
-static void dump(LabelTable &labels) 
-{    
-#if 1
-  TRACE( "==== Label Table ====");
-  for ( int i=1 ; i<=99999 ;i++) {
-    psr::Provenance p;
-    if ( labels.find(i,p) ) {
-      TRACE( "  #" << i << " at " << p.offset() ) ;
-    }
-  }
-  TRACE( "=====================");
-#endif
-}
-
-
-using SMap = sm::StatementMap;
-
-namespace Fortran::parser { 
-
-
-class Pass1 : public LabelTableStack 
-{
-  
-public:
-  
-  Pass1(const psr::CookedSource &source) :
-    source_(source), 
-    current_label_(-1) ,
-    current_smap_(0)
-  {
-    system_scope_  = &Scope::systemScope;
-    unit_scope_    = &Scope::globalScope;
-    current_scope_ = nullptr ;
-  }   
-
-public:
-
-  // Remark: Ideally those fields shall not be directly accessible.
-  //         Make them private in a base class? 
-  
-  const psr::CookedSource &source_ ;
-  int current_label_; // hold the value of a statement label until it get consumed (-1 means none) 
-  Provenance current_label_loc_; 
-  const Scope * system_scope_ ; 
-  Scope * unit_scope_; 
-  Scope * current_scope_ ; 
-  SMap * current_smap_ ;
-
-  std::map<SMap::Index, sm::Name> construct_name_ ;
-
-  // Provide all label-DO statements that are still open.
-  // The key is the LabelDoStmt index
-  // The value is the required label.
-  //
-  // TODO: WARNING: That table is shared by all program, functions 
-  // and subroutines in the same unit. However, the labels are not
-  // shared which means that there is a risk of conflict.
-  //
-  // Fortunately, that table life time is quite short and it is
-  // supposed to empty itself. Some assert(opened_label_do_.empty()) 
-  // shall be inserted before and after switching context.
-  //
-  std::map<SMap::Index,int> opened_label_do_;
-
-public:
-  
-  Scope * EnterScope(Scope &s) { 
-    assert( &s.parent() == current_scope_ ) ;
-    current_scope_ = &s ; 
-    return &s;
-  } 
-
-  void LeaveScope(Scope::Kind k) {
-    assert( current_scope_->kind() == k ) ; 
-    current_scope_ = const_cast<Scope*>(&current_scope_->parent()) ; 
-  }
-
-  Provenance GetProvenance(const CharBlock &source) {
-    return source_.GetProvenance(source.begin()).start() ;
-  }
-
-  // Trace the location and label of any x with an accessible Statement<> in its type.
-  template <typename T> void TraceStatementInfo(const T &x) { 
-    auto & s = GetStatementValue(x) ;
-    // TODO: compilation will fail is 's' is not of type Statement<...>.
-    // Do we have a type trait to detect Statement<>?  
-    //  if constexpr ( s is a Statement<> ) {
-    if ( s.label ) {
-      TRACE("stmt: loc=" << s.provenance.offset() << " label=" << s.label ) ; 
-    } else {
-      TRACE("stmt: loc=" << s.provenance.offset()  ) ; 
-    }
-    // } else {  TRACE("stmt: none") ; } 
-  } 
-
-  void SpecializeDoStmt( SMap::Index dostmt , const std::optional<psr::LoopControl> & control) 
-  {
-    auto & smap = GetStatementMap(); 
-
-    StmtClass do_class = smap.GetClass(dostmt);
-    StmtClass do_while_class;
-    StmtClass do_concurrent_class;
-
-    if ( do_class == StmtClass::NonLabelDo ) {
-      do_while_class = StmtClass::NonLabelDoWhile;
-      do_concurrent_class = StmtClass::NonLabelDoConcurrent;
-    } else if ( do_class == StmtClass::LabelDo ) {
-      do_while_class = StmtClass::LabelDoWhile;
-      do_concurrent_class = StmtClass::LabelDoConcurrent;
-    } else {
-      INTERNAL_ERROR;
-      return ;
-    }
-
-    if ( control ) { 
-      std::visit( 
-        visitors{
-         [&] (const psr::LoopBounds<psr::ScalarIntExpr> &x) {
-           // keep the do_class. Do nothing
-         },
-         [&] (const psr::LoopControl::Concurrent &x) {
-           smap.Specialize(dostmt, do_class, do_concurrent_class);
-         },
-         [&] (const psr::ScalarLogicalExpr&x) {
-           smap.Specialize(dostmt, do_class, do_while_class);
-         },
-         [](const auto &x) {
-           // TODO
-           return semantics::DeclTypeSpec::MakeTypeStar();
-         },
-       },
-       control->u);
-    } else {
-      smap.Specialize(dostmt, do_class, do_while_class);
-    }
-       
-  }
-
-
-public:
-
-  void ClearConstructNames() {
-    construct_name_.clear() ;
-  }
-  
-
-  //
-  // TODO: Should operate with Symbol instead of Name
-  //
-  std::optional<sm::Name> GetConstructName(SMap::Index stmt) {
-    auto it = construct_name_.find(stmt);
-    if ( it == construct_name_.end() ) {
-      return std::nullopt ; 
-    }
-    return it->second;
-  }
-
-  // 
-  void 
-  SetConstructName(SMap::Index stmt, const psr::Name &name) {
-    construct_name_.insert_or_assign(stmt, name.ToString() );
-  }
-
-  // 
-  void 
-  SetConstructName(SMap::Index stmt, const std::optional<psr::Name>& name) {
-    if (name) {
-      SetConstructName(stmt,*name) ;
-    }
-  }
-
-  void 
-  CheckStatementName( SMap::Index part_or_end, const std::optional<psr::Name> &found, bool required) {
-    
-    auto & smap = GetStatementMap() ;
-
-    assert( smap.GetGroup(part_or_end) == StmtGroup::Part ||
-            smap.GetGroup(part_or_end) == StmtGroup::End );
-            
-    SMap::Index start = smap.StartOfConstruct(part_or_end); 
-    assert( smap.GetGroup(start) == StmtGroup::Start );
-
-    
-
-    std::optional<sm::Name> expect = GetConstructName(start);
-   
-    // TODO: Get the location from part_or_end
-    const char * text = StmtClassText( smap.GetClass(part_or_end) ) ;
-    if ( expect ) {      
-      if ( found ) {
-        if ( found->ToString() != *expect ) {
-          FAIL("In statement #" << part_or_end 
-               << ": Unexpected name '" << found->ToString() << "' in " << text
-               << "' (expected '" << *expect << "') ");
-        } 
-      } else if ( required) {
-        FAIL("In statement #" << part_or_end 
-             << ": Missing name '" << *expect << "' in " << text);
-      }
-    } else if ( found ) {
-      FAIL("In statement #" << part_or_end 
-           << ": Unexpected name '" << found->ToString() << "' in " << text << "' (none expected) ");
-    }
-  }
-
-public:
-
-
-  SMap & GetStatementMap()
-  {
-    assert(current_smap_) ;
-    return *current_smap_ ;
-  }
-  
-  void OpenLabelDo(SMap::Index dostmt, int label) 
-  { 
-    opened_label_do_[dostmt] = label ;
-  }
-  
-  void CloseLabelDo(SMap::Index dostmt) 
-  { 
-    opened_label_do_.erase(dostmt) ;
-  }
-
-  // If stmt is an opened LabelDo, then return its label.  
-  // In all other cases, return 0.
-  //
-  // This function can be safely called even if stmt is 
-  // not a LabelStmt
-  // 
-  int GetLabelOfOpenedLabelDo(SMap::Index stmt) 
-  {         
-    auto it = opened_label_do_.find(stmt);
-    if ( it != opened_label_do_.end() ) 
-      return it->second ;
-    else
-      return 0 ; 
-  }
-
-  // return true if the specified label matches any currently opened LabelDo
-  bool MatchAnyOpenedLabelDo(int label) 
-  {         
-    if ( label > 0 ) {
-      auto smap = GetStatementMap() ; 
-      for (auto it : opened_label_do_ ) {
-        if ( it.second == label )
-          return true;
-      }
-    }
-    return false; 
-  }
-  
-
-  bool ValidEndOfLabelDo(StmtClass sclass) 
-  {
-    
-
-    if ( sclass == StmtClass::Continue ) return true ; 
-    if ( sclass == StmtClass::EndDo ) return true ; 
-
-
-    // Add below, all statement classes that we want to allow for 
-    // backward compatibility with old codes or standards.
-    if (true) {
-      // Most action statements should be legal 
-      // TODO: did I miss something?
-      if ( sclass == StmtClass::Allocate) return true ;  
-      if ( sclass == StmtClass::ArithmeticIf) return true ; 
-      if ( sclass == StmtClass::Assign) return true ;  
-      if ( sclass == StmtClass::AssignedGoto) return true ; 
-      if ( sclass == StmtClass::Assignment) return true ; 
-      if ( sclass == StmtClass::Backspace) return true ;  
-      if ( sclass == StmtClass::Call) return true ;  
-      if ( sclass == StmtClass::Close) return true ; 
-      if ( sclass == StmtClass::ComputedGoto) return true ;  
-      if ( sclass == StmtClass::Cycle) return true ;  
-      if ( sclass == StmtClass::Deallocate) return true ; 
-      if ( sclass == StmtClass::Endfile) return true ;  
-      if ( sclass == StmtClass::EventPost) return true ; 
-      if ( sclass == StmtClass::EventWait) return true ;  
-      if ( sclass == StmtClass::Exit) return true ;  
-      if ( sclass == StmtClass::FailImage) return true ;  
-      if ( sclass == StmtClass::Flush) return true ; 
-      if ( sclass == StmtClass::Forall) return true ; 
-      if ( sclass == StmtClass::FormTeam) return true ;  
-      if ( sclass == StmtClass::Goto) return true ; 
-      if ( sclass == StmtClass::Inquire) return true ;  
-      if ( sclass == StmtClass::Lock) return true ; 
-      if ( sclass == StmtClass::Nullify) return true ;  
-      if ( sclass == StmtClass::Open) return true ; 
-      if ( sclass == StmtClass::Pause) return true ; 
-      if ( sclass == StmtClass::PointerAssignment) return true ;  
-      if ( sclass == StmtClass::Print ) return true ; 
-      if ( sclass == StmtClass::Print) return true ; 
-      if ( sclass == StmtClass::Read) return true ;  
-      if ( sclass == StmtClass::Redimension) return true ;  
-      if ( sclass == StmtClass::Return) return true ;  
-      if ( sclass == StmtClass::Rewind) return true ; 
-      if ( sclass == StmtClass::Stop) return true ;  
-      if ( sclass == StmtClass::SyncAll) return true ; 
-      if ( sclass == StmtClass::SyncImages) return true ;  
-      if ( sclass == StmtClass::SyncMemory) return true ; 
-      if ( sclass == StmtClass::SyncTeam) return true ;  
-      if ( sclass == StmtClass::Unlock) return true ;  
-      if ( sclass == StmtClass::Wait) return true ; 
-      if ( sclass == StmtClass::Where) return true ;  
-      if ( sclass == StmtClass::Write) return true ; 
-
-      // Is the following legal? Maybe
-      if ( sclass == StmtClass::Format) return true ;  // TODO: is that legal?
-      //if ( sclass == StmtClass::Data) return true ;  // TODO: is that legal?
-      //if ( sclass == StmtClass::Entry) return true ; // TODO: is that legal?
-
-      // TODO Is there anything special to do here for Cycle and Exit? Probably not.
-      
-      // I do not know how standard that is but GFortran 
-      // is accepting non-construct IF as in
-      //
-      //    DO 666 i=1,10
-      //    666 IF (i>4) PRINT *,i 
-      //
-      // The InitStmt function below was designed to 
-      // also handle that case. 
-      //
-      if ( sclass == StmtClass::If ) return true ; 
-
-    }
-
-    return false ; 
-  }
-
-
-  void CheckNoOpenedLabelDo( SMap::Index stmt, int label ) {
-      if ( MatchAnyOpenedLabelDo(label) ) {
-        FAIL("Statement with label " << label << " is not properly"
-             " nested to close all corresponding label DO statement");
-      }
-  }
-  
-  // Check if adding a statement of class 'sclass' with the 
-  // specified 'label' can legally close some opened DoLabel.
-  // 
-  // Note: This is also the place where LabelDo terminated by
-  // a Enddo are marked as closed.
-  //
-  // TODO: add a Provenance argument for the stmt 
-  //
-  void CheckValidityOfEndingLabelDo(StmtClass sclass, int stmt_label ) 
-  { 
-    auto & smap = GetStatementMap() ;
-    if ( smap.Size() == 0 ) 
-      return ;
-    
-    StmtGroup sgroup = StmtClassToGroup(sclass) ;
-    SMap::Index last = smap.Last(); 
-    SMap::Index label_do = SMap::None;
-    if ( smap.GetGroup(last) == StmtGroup::Single ) {
-      label_do = smap.GetParent(last) ;
-    } else if ( smap.GetGroup(last) == StmtGroup::End ) {
-      label_do = smap.GetParent(smap.StartOfConstruct(last)) ;
-    } 
-    if ( label_do != SMap::None ) {
-      if ( smap.GetClass(label_do) == StmtClass::LabelDo ) {
-        if (  GetLabelOfOpenedLabelDo(label_do) == stmt_label ) {
-          if ( ! ValidEndOfLabelDo(sclass) ) {
-            FAIL("Statement cannot end a DO label");
-          } else if ( sclass == StmtClass::EndDo ) {
-            CloseLabelDo(label_do);
-          }
-        } else if ( sclass == StmtClass::EndDo ) {
-          FAIL("ENDDO label does not match previous DO-label");
-        } else if ( sgroup==StmtGroup::Part || sgroup==StmtGroup::End ) {
-          FAIL("Unterminated DO-label statement");
-        }
-      }
-    }
-  }
-
-  void CloseLabelDoLoopsWithStmtLabel(SMap::Index closing_stmt) 
-  {
-    auto & smap = GetStatementMap() ;
-    auto sclass = smap.GetClass(closing_stmt);
-    auto sgroup = smap.GetGroup(closing_stmt);
-    
-    // Ending a LabelDo using a construct is handled when 
-    // the 'end' of that construct is inserted so not now.
-    if ( sgroup == StmtGroup::Start )
-      return ;
-
-    // LabelDo cannot be closed by a label on a statement part
-    if ( sgroup == StmtGroup::Part )
-      return ;
-
-    if ( sgroup == StmtGroup::End && sclass != StmtClass::EndDo ) {
-      // Try to close using the label on construct that was just ended.
-      // Note: this is usually not legal except in a few rare cases.
-      //       see ValidEndOfLabelDo() for more details.
-      closing_stmt = smap.StartOfConstruct(closing_stmt);
-    }
-    
-    int closing_label = smap.GetLabel(closing_stmt)  ;
-    if ( closing_label == 0 ) 
-      return; 
-      
-    SMap::Index parent ;
-
-    if ( sclass == StmtClass::EndDo ) {
-      // Skip the loop that we just closed by adding an
-      // ENDDO into the map.
-      parent = smap.GetParent(smap.StartOfConstruct(closing_stmt)) ;
-    } else {
-      parent = smap.GetParent(closing_stmt) ;          
-    }
-
-    // Insert a DummyEndDo for each surrounding LabelDo that
-    // matches the label of the added statement or construct.
-    //
-    // By construction the LabelDo loops should be perfectly nested
-    // except if some directives are inserted (e.g. OpenMP parallel,
-    // OpenACC loop, ...).  Though, we have to wonder if loop directives 
-    // shall be allowed to break a loop nest sharing the same end-label.
-    //
-    while (  parent != SMap::None 
-             && GetLabelOfOpenedLabelDo(parent) == closing_label
-             ) 
-      {              
-        auto name = GetConstructName(parent);
-        if (name) {
-          //
-          // DummyEndDo cannot be used to close a named LabelDo.
-          // For instance, the following is not legal:
-          //
-          //   foobar: DO 666 i=1,n
-          //   ...
-          //   666 CONTINUE
-          //
-          FAIL("Statement #" << closing_stmt 
-               << " cannot be used to close named DO label #" 
-               << parent) ;
-        }
-        smap.Add( StmtClass::DummyEndDo, 0 ) ; 
-        CloseLabelDo(parent) ;
-        parent = smap.GetParent(parent) ;
-      }
-    
-    if ( MatchAnyOpenedLabelDo(closing_label) ) {
-      FAIL("Statement " <<  closing_stmt << " is not properly"
-           " nested to close all corresponding label DO statement");
-    }
-    
-  }
-  
-  // Initialize a statement.
-  
-  template<typename T> 
-  sm::Semantic<T> & InitStmt( const T &stmt, StmtClass sclass  )
-  {
-    auto & sema = InitSema(stmt);
-    auto & smap = GetStatementMap() ;
-
-    // Consume the label installed by the surrounding Statement<...>
-    int stmt_label = 0 ;
-    if ( current_label_ >=  0 ) { 
-      stmt_label = current_label_ ;
-
-      // Special case: The statement after the non-construct IF, 
-      // FORALL and WHERE do not have an associated Statement<...>
-      // so simulate an 'unset' label for those
-      if ( std::is_same<T,psr::IfStmt>::value |
-           std::is_same<T,psr::ForallStmt>::value |
-           std::is_same<T,psr::WhereStmt>::value) {
-        current_label_ = 0 ;      
-      } else {
-        // else mark the label as consumed
-        current_label_ = -1 ;
-      }
-
-       if ( stmt_label != 0 ) {
-        LabelTable & label_table = GetLabelTable() ;
-        Provenance old_loc ; 
-        if ( label_table.find(stmt_label, old_loc) ) {
-          FAIL("Duplicate label " << stmt_label 
-               << "at @" << current_label_loc_.offset() 
-               << "and @" << old_loc.offset() ) ;          
-        } else {
-          label_table.add( stmt_label, current_label_loc_) ;
-        }
-      }
-
-    } else {
-      FAIL("No label to consume in " << __PRETTY_FUNCTION__ );      
-    }
-        
-    CheckValidityOfEndingLabelDo(sclass, stmt_label) ;
-
-    // Now, add our statement.
-    int stmt_index = smap.Add( sclass, stmt_label ) ;    
-
-    // and then close as many LabelDo as possible using the 
-    // label of the statement we just added (or the label 
-    // of the construct that the statement just ended).
-    CloseLabelDoLoopsWithStmtLabel(stmt_index);
-    
-    // If the label of the added statement was supposed to 
-    // close some opened LabelDo then they should now be all 
-    // be closed. 
-    if ( MatchAnyOpenedLabelDo(stmt_label) ) {
-      FAIL("Statement with label " <<  stmt_index << " is not properly"
-           " nested to close all corresponding label DO statement");
-    }
-    
-    sema.stmt_index = stmt_index; 
-    return sema;
-  }
-
-public:
-
-  template <typename T> bool Pre(const T &x) { 
-    if ( ENV("TRACE_FALLBACK")  )  
-      TRACE( "*** fallback Pre(" << sm::GetTypeName(x) << ")" )  ;
-    
-    //  TRACE( "*** fallback " << __PRETTY_FUNCTION__  ) ; 
-    return true ;
-  }
-  
-  template <typename T> void Post(const T &) { 
-  //  if ( ENV("TRACE_FALLBACK") )  
-  //    TRACE( "*** fallback " << __PRETTY_FUNCTION__  ) ; 
-  }
-  
-  // fallback for std::variant
-
-
-  template <typename... A> bool Pre(const std::variant<A...> &) { 
-    //std::cerr << "@@@ fallback " << __PRETTY_FUNCTION__  << "\n" ; 
-    return true;
-  }
-  
-  template <typename... A> void Post(const std::variant<A...> &) { 
-    // std::cerr << "@@@ fallback " << __PRETTY_FUNCTION__  << "\n" ; 
-  }
-  
-  // fallback for std::tuple
-
-  template <typename... A> bool Pre(const std::tuple<A...> &) { 
-    // std::cerr << "@@@ fallback " << __PRETTY_FUNCTION__  << "\n" ; 
-    return true;
-  }
-
-  template <typename... A> void Post(const std::tuple<A...> &) { 
-    //  std::cerr << "@@@ fallback " << __PRETTY_FUNCTION__  << "\n" ; 
-  }
-
-  // fallback for std::string
-
-  bool Pre(const std::string &x) { 
-    // std::cerr << "@@@ fallback " << __PRETTY_FUNCTION__  << "\n" ; 
-    return true ;
-  }
-
-  void Post(const std::string &) { 
-    // std::cerr << "@@@ fallback " << __PRETTY_FUNCTION__  << "\n" ; 
-  }
-
-  // fallback for Indirection<>
-
-  template <typename T> bool Pre(const psr::Indirection<T> &x) { 
-    // std::cerr << "@@@ fallback " << __PRETTY_FUNCTION__  << "\n" ; 
-    return true ;
-  }
-
-  template <typename T> void Post(const psr::Indirection<T> &) { 
-    // std::cerr << "@@@ fallback " << __PRETTY_FUNCTION__  << "\n" ; 
-  }
-
-
-
-  //  ========== Statement<>  ===========
-
-  template <typename T>
-  bool Pre(const psr::Statement<T> &x) { 
-
-    // Each and every label must be consumed by a statement.
-    if ( current_label_ != -1 ) {
-      TRACE("*** Label " << current_label_ << " (" << current_label_loc_.offset() 
-            << ") was not consumed in " << __PRETTY_FUNCTION__ );
-    }
-
-    // Store the label for the next statement.
-    // The value 0 indicates not label but zero shall be consumed like any other
-    // label. 
-    current_label_ = 0 ; 
-    current_label_loc_ = GetProvenance(x.source) ;
-    if ( x.label.has_value() ) {
-      //
-      // TODO: The parser stores the label in a std::uint64_t but does not report overflow
-      //       which means that the following labels are currently accepted as valid and
-      ///      we have no ways to detect them.
-      //         18446744073709551617 = 2^64+1 = 1
-      //         18446744073709551618 = 2^64+2 = 2
-      //         ...
-      //
-      if ( 1 <= x.label.value() && x.label.value() <= 99999 ) {
-        current_label_ = x.label.value() ; 
-      } else {
-        FAIL( "##### Illegal label value " << x.label.value() << " at @" << current_label_loc_.offset() ) ;
-      }
-    } 
-    return true ; 
-  }
-
-  template <typename T>
-  void Post(const psr::Statement<T> &x) { 
-    // Check that the label was consumed
-    // Each Statement shall be associated to a class acting as a statement 
-    if ( current_label_!=-1 )  {
-      TRACE("*** Label " << current_label_ << " (" << current_label_loc_.offset() 
-            << ") was not consumed in " << __PRETTY_FUNCTION__ );
-      current_label_=-1 ;
-    }
-  }
-
-  
-  // ========== ProgramUnit  ===========
-
-  bool Pre(const ProgramUnit &x) { 
-    TRACE_CALL() ;
-    current_scope_ = unit_scope_;
-    auto & sema = InitSema(x);
-
-    // Install the statement map for future GetStatementMap() 
-    sema.statement_map = new SMap;
-    assert(!current_smap_);
-    current_smap_ = sema.statement_map;
-   
-    ClearConstructNames() ;    
-
-    return true ; 
-  }
-
-  void Post(const ProgramUnit &x) {
-    TRACE_CALL() ;
-    std::cerr << "DUMP STMT " << GetStatementMap().Size() << "\n";
-    //  GetStatementMap().DumpFlat(std::cerr);
-    //  std::cerr << "========================\n";
-    GetStatementMap().Dump(std::cerr,1,true);
-    current_smap_ = 0;
-
-#if 0 
-    // #### rewrite StmtFunctionStmt into AssignmentStmt
-    // #### This is an experiment.
-    // #### Currently not working
-    
-    const SpecificationPart & specif_part = std::get<SpecificationPart>(x.t) ;
-    auto &const_decl_list = std::get< std::list<DeclarationConstruct> >(specif_part.t);   
-    // Reminder: ExecutionPart = std::list<ExecutionPartConstruct>
-    auto &const_exec_list = std::get< std::list<ExecutionPartConstruct> >(x.t);  
-
-    // We are going to move elements from decl_list to exec_list so get rid of the const.
-    auto &decl_list = unconst(const_decl_list);
-    auto &exec_part = unconst(const_exec_part);
-    
-    // The goal is to remove some StmtFunctionStmt at the end of decl_list
-    // and to insert them in the same order at the begining of excl_part
-    //
-    // for instance:
-    // 
-    //  - Before:
-    //       ! decl_list contains 4 elements 
-    //       integer,intent(in) :: i,n
-    //       integer :: a,b(n),c(n)
-    //       b(i) = i*10     ! StmtFunctionStmt
-    //       c(i) = i*i      ! StmtFunctionStmt        
-    //       ! exec_part contains 1 element
-    //       print *, "hello" , b(1), c(1)
-    //
-    //  - After:
-    //       ! decl_list contains 2 elements 
-    //       integer,intent(in) :: i,n
-    //       integer :: a, b(n), c(n)
-    //       ! exec_part contains 3 element
-    //       b(i) = i*10
-    //       c(i) = i*i              
-    //       print *, "hello" , b(1), c(1)
-    // 
-
-    // For the purpose of that experiment, convert all StmtFunctionStmt 
-    // found at the end of decl_list.
-    // The final code shall be more selective. 
-    
-    // A stupid alias for readability purpose
-    typedef Statement<Indirection<StmtFunctionStmt>>> StmtFunctionStmt_type;
-
-    while (true) {
-      if (decl_list.empty())
-        break ;
-      DeclarationConstruct &last = decl_list.back() ; 
-      if ( ! std::holds_alternative<StmtFunctionStmt_type>(last.v) )
-        break ;
-      auto & func_stmt = GetValue( std::get<StmtFunctionStmt_type>(last.v) ) ;
-      
-      auto & funcname = unconst(func_stmt.name());
-      auto & arglist  = unconst(func_stmt.args());
-      auto & rhs      = GetValue(unconst(func_stmt.expr()));               
-                                 
-      psr::DataRef base(...);
-      std::list<SectionSubscript> sslist;
-      for ( Name &index : arglist ){
-        // SectionSubscript -> Expr -> Designator -> DataRef -> Name = index
-        SectionSubscript ss(...);
-        sslist.push_back(ss); 
-      }
-      psr::ArrayElement elem(base,sslist);
-      ExecutionPartConstruct(ExecutableConstruct(StatementActionStmt(
-      decl_list.pop_back() ;
-    }
-#endif
-
-    ClearConstructNames() ;    
-  }
-
-  //  ========== MainProgram  ===========
-
-  bool Pre(const MainProgram &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitSema(x); 
-
-    // const ProgramStmt * program_stmt = GetOptValue( std::get<x.PROG>(x.t) ) ;
-
-    // Install the scope 
-    sema.scope_provider = EnterScope( current_scope_->MakeScope(Scope::Kind::MainProgram) )  ; 
-
-    // Install the label table
-    sema.label_table = PushLabelTable( new LabelTable ) ;
-
-    return true ; 
-  }
-
-  void Post(const MainProgram &x) { 
-    auto &sema = GetSema(x); 
-    dump(GetLabelTable()) ; 
-    PopLabelTable(sema.label_table)  ;     
-    LeaveScope(Scope::Kind::MainProgram)  ;     
-    TRACE_CALL() ;
-  }
-
-  //  ========== FunctionSubprogram  ===========
-
-  bool Pre(const FunctionSubprogram &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitSema(x); 
-
-    // const FunctionStmt    & function_stmt = GetValue(std::get<x.FUNC>(x.t)) ; 
-    // const EndFunctionStmt & end_stmt      = GetValue(std::get<x.END>(x.t)) ; 
-
-    sema.scope_provider = EnterScope( current_scope_->MakeScope(Scope::Kind::Subprogram) )  ; 
-
-    // Install the label table
-    sema.label_table = PushLabelTable( new LabelTable ) ;
-
-    return true ; 
-  }
-
-  void Post(const FunctionSubprogram &x) { 
-    TRACE_CALL() ;
-    auto &sema = GetSema(x); 
-    dump(GetLabelTable()) ; 
-    PopLabelTable(sema.label_table)  ;     
-    LeaveScope(Scope::Kind::Subprogram);
-  }
-
-  //  ========== SubroutineSubprogram  ===========
-
-  bool Pre(const SubroutineSubprogram &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitSema(x); 
-
-    // const SubroutineStmt    & subroutine_stmt = GetValue(std::get<x.SUBR>(x.t)) ; 
-    // const EndSubroutineStmt & end_stmt      = GetValue(std::get<x.END>(x.t)) ; 
-
-    sema.scope_provider = EnterScope( current_scope_->MakeScope(Scope::Kind::Subprogram) )  ; 
-
-    // Install the label table
-    sema.label_table = PushLabelTable( new LabelTable ) ;
-
-    return true ; 
-  }
-
-  void Post(const SubroutineSubprogram &x) { 
-    TRACE_CALL() ;
-    auto &sema = GetSema(x); 
-    dump(GetLabelTable()) ; 
-    PopLabelTable(sema.label_table)  ;  
-    if ( ! opened_label_do_.empty() ) 
-      INTERNAL_ERROR;
-    LeaveScope(Scope::Kind::Subprogram)  ; 
-  }
-
-
-  //  ========== Module  ===========
-
-  bool Pre(const Module &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitSema(x); 
-
-    // const ModuleStmt    & module_stmt = GetValue(std::get<x.MOD>(x.t)) ; 
-    // const EndModuleStmt & end_stmt    = GetValue(std::get<x.END>(x.t)) ; 
-
-    sema.scope_provider = EnterScope( current_scope_->MakeScope(Scope::Kind::Module) )  ; 
-
-    // Install the label table
-    sema.label_table = PushLabelTable( new LabelTable ) ;
-
-    return true ; 
-  }
-
-  void Post(const Module &x) { 
-    TRACE_CALL() ;
-    auto &sema = GetSema(x); 
-    dump(GetLabelTable()) ; 
-    PopLabelTable(sema.label_table)  ;     
-    LeaveScope(Scope::Kind::Module)  ;     
-  }
-
-
-  // =========== BlockData =========== 
-
-  bool Pre(const BlockData &x) { 
-    TRACE_CALL() ;
-    return true ; 
-  }
-
-  void Post(const BlockData &x) { 
-    TRACE_CALL() ;
-  }
-
-
-  // =========== DerivedTypeDef =========== 
-  // WARNING: there is also a sm::DerivedTypeDef defined in types.h 
-  bool Pre(const psr::DerivedTypeDef &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitSema(x); 
-    (void) sema ; 
-    sema.scope_provider=0; // TODO: Install a scope?
-    return true ; 
-  }
-
-  void Post(const psr::DerivedTypeDef &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== DerivedTypeStmt =========== 
-
-  bool Pre(const DerivedTypeStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::DerivedType);
-
-    auto &name = std::get<1>(x.t);
-    SetConstructName(sema.stmt_index, name);
-
-    return true ; 
-  }
-
-  void Post(const DerivedTypeStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndTypeStmt =========== 
-
-  bool Pre(const EndTypeStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::EndType);
-
-    auto &name = x.v ;
-    CheckStatementName(sema.stmt_index, name, false); 
-
-    return true ; 
-  }
-
-  void Post(const EndTypeStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ModuleStmt =========== 
-
-  bool Pre(const ModuleStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::Module);     
-
-    auto &name = x.v;
-    SetConstructName(sema.stmt_index, name);
-
-    return true ; 
-  }
-
-  void Post(const ModuleStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndModuleStmt =========== 
-
-  bool Pre(const EndModuleStmt &x) { 
-    TRACE_CALL() ;
-     auto &sema = InitStmt(x, StmtClass::EndModule); 
-
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, false); 
-
-    return true ; 
-  }
-
-  void Post(const EndModuleStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== SubroutineStmt =========== 
-
-  bool Pre(const SubroutineStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::Subroutine);
- 
-    auto &name = std::get<psr::Name>(x.t);
-    SetConstructName(sema.stmt_index, name);
-
-    return true ; 
-  }
-
-  void Post(const SubroutineStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndSubroutineStmt =========== 
-
-  bool Pre(const EndSubroutineStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema =  InitStmt(x, StmtClass::EndSubroutine); 
-
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, false); 
-    return true ; 
-  }
-
-  // =========== FunctionStmt =========== 
-
-  bool Pre(const FunctionStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema =  InitStmt(x, StmtClass::Function); 
-
-    auto &name = std::get<psr::Name>(x.t);
-    SetConstructName(sema.stmt_index, name);
-
-    return true ; 
-  }
-
-  void Post(const FunctionStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndFunctionStmt =========== 
-
-  bool Pre(const EndFunctionStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema =  InitStmt(x, StmtClass::EndFunction);
-    
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, false); 
-
-    return true ; 
-  }
-
-  void Post(const EndFunctionStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== TypeDeclarationStmt =========== 
-
-  bool Pre(const TypeDeclarationStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::TypeDeclaration); 
-    return true ; 
-  }
-
-  void Post(const TypeDeclarationStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-
-  // =========== ImplicitStmt =========== 
-
-  bool Pre(const ImplicitStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Implicit); 
-    return true ; 
-  }
-
-  void Post(const ImplicitStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== UseStmt =========== 
-
-  bool Pre(const UseStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Use); 
-    return true ; 
-  }
-
-  void Post(const UseStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== PrintStmt =========== 
-
-  bool Pre(const PrintStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Print); 
-    return true ; 
-  }
-
-  void Post(const PrintStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== AssignmentStmt =========== 
-
-  bool Pre(const AssignmentStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Assignment); 
-    
-
-    return true ; 
-  }
-
-  void Post(const AssignmentStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ProgramStmt =========== 
-
-  bool Pre(const ProgramStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::Program); 
-    
-    auto &name = x.v;
-    SetConstructName(sema.stmt_index, name);
-
-       
-    return true ; 
-  }
-
-  void Post(const ProgramStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndProgramStmt =========== 
-
-  bool Pre(const EndProgramStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema =InitStmt(x, StmtClass::EndProgram);
-
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, false); 
-
-    return true ; 
-  }
-
-  void Post(const EndProgramStmt &x) {     
-    TRACE_CALL() ;
-  }
-
-  
-  // =========== ComponentDefStmt =========== 
-
-  bool Pre(const ComponentDefStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::ComponentDef);
-    return true ; 
-  }
-
-  void Post(const ComponentDefStmt &x) { 
-    TRACE_CALL() ;
-  }
-    // =========== AccessStmt =========== 
-
-  bool Pre(const AccessStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Access);
-    return true ; 
-  }
-
-  void Post(const AccessStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-    // =========== AllocatableStmt =========== 
-
-  bool Pre(const AllocatableStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Allocatable);
-    return true ; 
-  }
-
-  void Post(const AllocatableStmt &x) { 
-    TRACE_CALL() ;
-  }
-  
-  // =========== AsynchronousStmt =========== 
-
-  bool Pre(const AsynchronousStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Asynchronous);    
-    return true ; 
-  }
-
-  void Post(const AsynchronousStmt &x) { 
-    TRACE_CALL() ;
-  }
-  // =========== BindStmt =========== 
-
-  bool Pre(const BindStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Bind);    
-    return true ; 
-  }
-
-  void Post(const BindStmt &x) { 
-    TRACE_CALL() ;
-  }
-  // =========== CodimensionStmt =========== 
-
-  bool Pre(const CodimensionStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Codimension);    
-    return true ; 
-  }
-
-  void Post(const CodimensionStmt &x) { 
-    TRACE_CALL() ;
-  }
-  
-  // =========== ContainsStmt =========== 
-
-  bool Pre(const ContainsStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Contains);    
-    return true ; 
-  }
-
-  void Post(const ContainsStmt &x) { 
-    TRACE_CALL() ;
-  }
-  
-  // =========== DimensionStmt =========== 
-
-  bool Pre(const DimensionStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Dimension);
-    return true ; 
-  }
-
-  void Post(const DimensionStmt &x) { 
-    TRACE_CALL() ;
-  }
-  // =========== ExternalStmt =========== 
-
-  bool Pre(const ExternalStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::External);
-    return true ; 
-  }
-
-  void Post(const ExternalStmt &x) { 
-    TRACE_CALL() ;
-  }
-  
-  // =========== IntentStmt =========== 
-
-  bool Pre(const IntentStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Intent);
-    return true ; 
-  }
-
-  void Post(const IntentStmt &x) { 
-    TRACE_CALL() ;
-  }
-  
-  // =========== IntrinsicStmt =========== 
-
-  bool Pre(const IntrinsicStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Intrinsic);
-    return true ; 
-  }
-
-  void Post(const IntrinsicStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== NamelistStmt =========== 
-
-  bool Pre(const NamelistStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Namelist);
-    return true ; 
-  }
-
-  void Post(const NamelistStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== OptionalStmt =========== 
-
-  bool Pre(const OptionalStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Optional);
-    return true ; 
-  }
-
-  void Post(const OptionalStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== PointerStmt =========== 
-
-  bool Pre(const PointerStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Pointer);
-    return true ; 
-  }
-
-  void Post(const PointerStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ProtectedStmt =========== 
-
-  bool Pre(const ProtectedStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Protected);
-    return true ; 
-  }
-
-  void Post(const ProtectedStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== SaveStmt =========== 
-
-  bool Pre(const SaveStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Save);
-    return true ; 
-  }
-
-  void Post(const SaveStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== TargetStmt =========== 
-
-  bool Pre(const TargetStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Target);
-    return true ; 
-  }
-
-  void Post(const TargetStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ValueStmt =========== 
-
-  bool Pre(const ValueStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Value);
-    return true ; 
-  }
-
-  void Post(const ValueStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== VolatileStmt =========== 
-
-  bool Pre(const VolatileStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Volatile);
-    return true ; 
-  }
-
-  void Post(const VolatileStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== CommonStmt =========== 
-
-  bool Pre(const CommonStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Common);
-    return true ; 
-  }
-
-  void Post(const CommonStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EquivalenceStmt =========== 
-
-  bool Pre(const EquivalenceStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Equivalence);
-    return true ; 
-  }
-
-  void Post(const EquivalenceStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== BasedPointerStmt =========== 
-
-  bool Pre(const BasedPointerStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::BasedPointer);
-    return true ; 
-  }
-
-  void Post(const BasedPointerStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== GenericStmt =========== 
-
-  bool Pre(const GenericStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Generic);
-    return true ; 
-  }
-
-  void Post(const GenericStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ParameterStmt =========== 
-
-  bool Pre(const ParameterStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Parameter);
-    return true ; 
-  }
-
-  void Post(const ParameterStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== BlockStmt =========== 
-  
-  bool Pre(const BlockStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::Block);
-    
-    auto &name = x.v;
-    SetConstructName(sema.stmt_index, name);
-    
-    return true ; 
-  }
-
-  void Post(const BlockStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-
-  // =========== EndBlockStmt =========== 
-  
-  bool Pre(const EndBlockStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::EndBlock);
-
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, true); 
-
-    return true ; 
-  }
-
-  void Post(const EndBlockStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-
-  // =========== ForallConstructStmt =========== 
-  
-  bool Pre(const ForallConstructStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::ForallConstruct);
-    
-    auto &name = std::get<0>(x.t);
-    SetConstructName(sema.stmt_index, name);
-    
-    return true ; 
-  }
-
-  void Post(const ForallConstructStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-
-  // =========== EndForallStmt =========== 
-  
-  bool Pre(const EndForallStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::EndForall);
-
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, true); 
-
-    return true ; 
-  }
-
-  void Post(const EndForallStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-
-
-  // =========== AssociateStmt =========== 
-  
-  bool Pre(const AssociateStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::Associate);
-    
-    auto &name = std::get<0>(x.t);
-    SetConstructName(sema.stmt_index, name);
-    
-    return true ; 
-  }
-
-  void Post(const AssociateStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-
-  // =========== EndAssociateStmt =========== 
-  
-  bool Pre(const EndAssociateStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::EndAssociate);
-
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, true); 
-
-    return true ; 
-  }
-
-  void Post(const EndAssociateStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ChangeTeamStmt =========== 
-  
-  bool Pre(const ChangeTeamStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::ChangeTeam);
-    
-    auto &name = std::get<0>(x.t);
-    SetConstructName(sema.stmt_index, name);
-    
-    return true ; 
-  }
-
-  void Post(const ChangeTeamStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndChangeTeamStmt =========== 
-  
-  bool Pre(const EndChangeTeamStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::EndChangeTeam);
-
-    auto &name = std::get<1>(x.t);
-    CheckStatementName(sema.stmt_index, name, true); 
-
-    return true ; 
-  }
-
-  void Post(const EndChangeTeamStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== CriticalStmt =========== 
-  
-  bool Pre(const CriticalStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::Critical);
-    
-    auto &name = std::get<0>(x.t);
-    SetConstructName(sema.stmt_index, name);
-    
-    return true ; 
-  }
-
-  void Post(const CriticalStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndCriticalStmt =========== 
-  
-  bool Pre(const EndCriticalStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::EndCritical);
-
-    auto &name = x.v ;
-    CheckStatementName(sema.stmt_index, name, true); 
-
-    return true ; 
-  }
-
-  void Post(const EndCriticalStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-
-  // =========== EnumeratorDef =========== 
-
-  bool Pre(const EnumeratorDefStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::EnumeratorDef);
-    return true ; 
-  }
-
-  void Post(const EnumeratorDefStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EnumDefStmt =========== 
-  
-  bool Pre(const EnumDefStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::EnumDef);
-    return true ; 
-  }
-
-  void Post(const EnumDefStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndEnumStmt =========== 
-
-  bool Pre(const EndEnumStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::EndEnum);
-    return true ; 
-  }
-
-  void Post(const EndEnumStmt &x) {
-    TRACE_CALL() ;
-  }
-
-  // =========== InterfaceStmt =========== 
-
-  bool Pre(const InterfaceStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Interface);
-    
-    // TODO: Compare the [generic-spec] with the END INTERFACE statement
-    return true ; 
-  }
-
-  void Post(const InterfaceStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndInterfaceStmt =========== 
-
-  bool Pre(const EndInterfaceStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::EndInterface);
-    // TODO: Compare the [generic-spec] with the INTERFACE statement
-    return true ; 
-  }
-
-  void Post(const EndInterfaceStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== IfThenStmt =========== 
-
-  bool Pre(const IfThenStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::IfThen);
-
-    auto &name = std::get<0>(x.t) ;
-    SetConstructName(sema.stmt_index, name);
-  
-    return true ; 
-  }
-
-  void Post(const IfThenStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ElseIfStmt =========== 
-
-  bool Pre(const ElseIfStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::ElseIf);
-
-    auto &name = std::get<1>(x.t);
-    CheckStatementName(sema.stmt_index, name, false); 
-    
-    return true ; 
-  }
-
-  void Post(const ElseIfStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ElseStmt =========== 
-
-  bool Pre(const ElseStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::Else);
-
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, false); 
-    
-    return true ; 
-  }
-
-  void Post(const ElseStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndIfStmt =========== 
-
-  bool Pre(const EndIfStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::EndIf);
-
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, true); 
-
-    return true ; 
-  }
-
-  void Post(const EndIfStmt &x) { 
-    TRACE_CALL() ;
-  }
- 
-  // =========== NonLabelDoStmt =========== 
-
-  bool Pre(const NonLabelDoStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::NonLabelDo);
-
-    auto &name = std::get<0>(x.t);
-    SetConstructName(sema.stmt_index, name);
-
-    // Specialize from StmtClass::LabelDo to StmtClass::NonLabelDoWhile or
-    // StmtClass::NonLabelDoConcurrent where applicable
-    SpecializeDoStmt( sema.stmt_index , std::get<std::optional<LoopControl>>(x.t) );
-
-    return true ; 
-  }
-
-  void Post(const NonLabelDoStmt &x) { 
-    TRACE_CALL() ;
- }
- 
-  // =========== LabelDoStmt =========== 
-
-  bool Pre(const LabelDoStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::LabelDo);
-    
-    auto &sema = GetSema(x);
-    // auto &smap = GetStatementMap() ;
-
-    int end_label = int(std::get<1>(x.t)) ; 
-    assert( 1 <= end_label && end_label <= 99999); // TODO: proper error
-    OpenLabelDo( sema.stmt_index, end_label);
-
-    Provenance previous_loc;
-    if ( GetLabelTable().find(end_label, previous_loc) ) {
-      // Early fail when the label already exists.
-      // This is actually optional since a "Duplicate Label" or "unexpected END statement"
-      // error will occur. 
-      FAIL("Label " << end_label << " required by DO statement is already declared") ;
-    }
-
-    // And also record the construct name 
-    auto &name = std::get<0>(x.t) ;
-    SetConstructName(sema.stmt_index, name);
-
-    // Specialize from StmtClass::LabelDo to StmtClass::LabelDoWhile or
-    // StmtClass::LabelDoConcurrent where applicable
-    SpecializeDoStmt( sema.stmt_index , std::get<std::optional<LoopControl>>(x.t) );
-
-    return true ; 
-  }
-
-  void Post(const LabelDoStmt &x) { 
-    TRACE_CALL() ;
-  }
- 
-  // =========== EndDoStmt =========== 
-
-  bool Pre(const EndDoStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::EndDo); 
-
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, true); 
-
-    return true ; 
-  }
-
-  void Post(const EndDoStmt &x) { 
-    TRACE_CALL() ;
-  }
- 
-
-  // =========== IfStmt =========== 
-
-  bool Pre(const IfStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::If);
-    return true ; 
-  }
-
-  void Post(const IfStmt &x) { 
-    TRACE_CALL() ;
-    GetStatementMap().Add( StmtClass::DummyEndIf, 0); 
-  }
-
-   // =========== SelectCaseStmt =========== 
-
-  bool Pre(const SelectCaseStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::SelectCase);
-
-    auto &name = std::get<0>(x.t);
-    SetConstructName(sema.stmt_index, name);    
-    
-    return true ; 
-  }
-
-  void Post(const SelectCaseStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== CaseStmt =========== 
-
-  bool Pre(const CaseStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Case);
-    
-    auto &sema = GetSema(x);
-    auto &smap = GetStatementMap() ;
-    
-    // Detect and specialize CASE into CASE DEFAULT 
-    if ( std::holds_alternative<psr::Default>(std::get<0>(x.t).u) )
-      {
-        // So this is a CASE DEFAULT
-
-        // Let's verify that there not already one
-        SMap::Index default_stmt = SMap::None; 
-#if 1
-        // Method 1: Manually visit the construct elements
-        // smap.VisistConstruct( sema.stmt_index,
-        smap.VisitConstructRev( sema.stmt_index,
-                              [&]( SMap::Index at ) -> bool 
-                              {
-                                if ( smap.GetClass(at) == StmtClass::CaseDefault ) {
-                                  default_stmt = at ;
-                                  return false;
-                                }
-                                return true; 
-                              } );
-#else     
-        // Method 2: Search for an previous StmtClass::CaseDefault
-        default_stmt = smap.FindPrevInConstruct(sema.stmt_index,
-                                                StmtClass::CaseDefault);
-#endif
-        if (default_stmt != SMap::None)
-          {
-            FAIL(" Duplicate CASE DEFAULT #" << default_stmt << " and #"
-                 << sema.stmt_index) ; 
-          }
-
-        // 
-        smap.Specialize(sema.stmt_index,
-                        StmtClass::Case,
-                        StmtClass::CaseDefault);
-      }
-    
-    // Check the construct name 
-    auto &name = std::get<1>(x.t);
-    CheckStatementName(sema.stmt_index, name, false); 
-
-    return true ; 
-  }
-
-  void Post(const CaseStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndSelectStmt =========== 
-
-  bool Pre(const EndSelectStmt &x) {
-    // Reminder: EndSelectStmt can end SelectCaseStmt, SelectTypeStmt or SelectRankStmt
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::EndSelect);
-
-    // Check the construct name 
-    auto &name = x.v;
-    CheckStatementName(sema.stmt_index, name, true); 
-
-    return true ; 
-  }
-
-  void Post(const EndSelectStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== SelectRankStmt =========== 
-
-  bool Pre(const SelectRankStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::SelectRank);
-
-    auto &name = std::get<0>(x.t);
-    SetConstructName(sema.stmt_index, name);    
-
-    return true ; 
-  }
-
-  void Post(const SelectRankStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== SelectRankCaseStmt =========== 
-
-  bool Pre(const SelectRankCaseStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::SelectRankCase);  
-
-    auto &sema = GetSema(x);
-    auto &smap = GetStatementMap() ;
-    
-    // Detect and specialize to StmtClass::SelectRankDefault 
-    // or StmtClass::SelectRankStar
-    if ( std::holds_alternative<psr::Default>(std::get<0>(x.t).u) )
-      {
-        // This is a RANK DEFAULT statement
-        
-        // Let's check that this is the only one
-        SMap::Index default_stmt = SMap::None; 
-        default_stmt = smap.FindPrevInConstruct(sema.stmt_index,
-                                                StmtClass::SelectRankDefault);
-        if (default_stmt != SMap::None)
-          {
-            FAIL(" Duplicate RANK DEFAULT in #" << default_stmt << " and #"
-                 << sema.stmt_index) ; 
-          }
-        
-        // And specialize to SelectRankSelectRankDefault in the SMap
-        smap.Specialize(sema.stmt_index,
-                        StmtClass::SelectRankCase,
-                        StmtClass::SelectRankDefault);
-
-      }
-    else if ( std::holds_alternative<psr::Star>(std::get<0>(x.t).u) )
-      {
-        // This is a RANK(*) statement
-        
-        // Let's check that this is the only one
-        SMap::Index default_stmt = SMap::None; 
-        default_stmt = smap.FindPrevInConstruct(sema.stmt_index,
-                                                StmtClass::SelectRankStar);
-        if (default_stmt != SMap::None)
-          {
-            FAIL(" Duplicate RANK(*) in #" << default_stmt << " and #"
-                 << sema.stmt_index) ; 
-          }
-
-        // And specialize to SelectRankStar in the SMap
-        smap.Specialize(sema.stmt_index,
-                        StmtClass::SelectRankCase,
-                        StmtClass::SelectRankStar);
-
-         // TODO: Install a scope to 'redeclare' the variable 
-     }
-    else
-      {
-        // This is a RANK(expr) statement
-
-        // TODO: evaluate the constant expression 
-        // TODO: compare the expression to other case (shall be unique)
-        // TODO: Install a scope to declare the variable with given rank.        
-      }
-
-    
-    // Check the construct name 
-    auto &name = std::get<1>(x.t);
-    CheckStatementName(sema.stmt_index, name, false); 
-
-
-    return true ; 
-  }
-
-  void Post(const SelectRankCaseStmt &x) {         
-    TRACE_CALL() ;
-  }
-
-  // =========== SelectTypeStmt =========== 
-
-  bool Pre(const SelectTypeStmt &x) { 
-    TRACE_CALL() ;
-    auto &sema = InitStmt(x, StmtClass::SelectType);
-
-    auto &name = std::get<0>(x.t);
-    SetConstructName(sema.stmt_index, name);    
-
-    return true ; 
-  }
-
-  void Post(const SelectTypeStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== TypeGuardStmt =========== 
-  // 
-  // That is 
-  //    TYPE IS (...) 
-  // or 
-  //    CLASS IS (...) 
-  // or
-  //    CLASS DEFAULT
-  // 
-
-  bool Pre(const TypeGuardStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::TypeGuard);
-    auto &sema = GetSema(x);
-    auto &smap = GetStatementMap() ;
-    
-    // Provide the proper specialization:
-    //  TYPE  IS      = StmtClass::TypeGuard  
-    //  CLASS IS      = StmtClass::ClassGuard  
-    //  CLASS DEFAULT = StmtClass::ClassDefault  
-    
-    if ( std::holds_alternative<psr::Default>(std::get<0>(x.t).u) )
-      {
-        // This is a CLASS DEFAULT statement
-        
-        // Let's check that this is the only one
-        SMap::Index default_stmt = SMap::None; 
-        default_stmt = smap.FindPrevInConstruct(sema.stmt_index,
-                                                StmtClass::ClassDefault);
-        if (default_stmt != SMap::None)
-          {
-            FAIL(" Duplicate RANK DEFAULT in #" << default_stmt
-                 << " and #" << sema.stmt_index) ; 
-          }
-        
-        // Specialize from TypeGuard to ClassDefault in the SMap
-        smap.Specialize(sema.stmt_index,
-                        StmtClass::TypeGuard,
-                        StmtClass::ClassDefault);
-
-      }
-    else if ( std::holds_alternative<psr::DerivedTypeSpec>(std::get<0>(x.t).u) )
-      {
-        // This is a CLASS IS (...) statement
-
-        // Specialize from TypeGuard to ClassGuard in the SMap
-        smap.Specialize(sema.stmt_index,
-                        StmtClass::TypeGuard,
-                        StmtClass::ClassGuard);
-
-         // TODO: ...
-     }
-    else
-      {
-        // This is a TYPE IS (...) statement
-        // TODO: ...
-      }
-
-    // Check the construct name.
-    auto &name = std::get<1>(x.t);
-    CheckStatementName(sema.stmt_index, name, false); 
-
-
-    return true ; 
-  }
-
-  void Post(const TypeGuardStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  
-
-  // =========== ProcedureDeclarationStmt =========== 
-
-  bool Pre(const ProcedureDeclarationStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::ProcedureDeclaration);
-    return true ; 
-  }
-
-  void Post(const ProcedureDeclarationStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== StructureStmt =========== 
-
-  bool Pre(const StructureStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Structure);
-    return true ; 
-  }
-
-  void Post(const StructureStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== StructureDef::EndStructureStmt =========== 
-
-  bool Pre(const StructureDef::EndStructureStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::EndStructure);
-    return true ; 
-  }
-
-  void Post(const StructureDef::EndStructureStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== FormatStmt =========== 
-
-  bool Pre(const FormatStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Format);
-    return true ; 
-  }
-
-  void Post(const FormatStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EntryStmt =========== 
-
-  bool Pre(const EntryStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Entry);
-    return true ; 
-  }
-
-  void Post(const EntryStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ImportStmt =========== 
-
-  bool Pre(const ImportStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Import);
-    return true ; 
-  }
-
-  void Post(const ImportStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== AllocateStmt =========== 
-
-  bool Pre(const AllocateStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Allocate);
-    return true ; 
-  }
-
-  void Post(const AllocateStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== BackspaceStmt =========== 
-
-  bool Pre(const BackspaceStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Backspace);
-    return true ; 
-  }
-
-  void Post(const BackspaceStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== CallStmt =========== 
-
-  bool Pre(const CallStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Call);
-    return true ; 
-  }
-
-  void Post(const CallStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== CloseStmt =========== 
-
-  bool Pre(const CloseStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Close);
-    return true ; 
-  }
-
-  void Post(const CloseStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ContinueStmt =========== 
-
-  bool Pre(const ContinueStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Continue);
-    return true ; 
-  }
-
-  void Post(const ContinueStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== DeallocateStmt =========== 
-
-  bool Pre(const DeallocateStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Deallocate);
-    return true ; 
-  }
-
-  void Post(const DeallocateStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EndfileStmt =========== 
-
-  bool Pre(const EndfileStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Endfile);
-    return true ; 
-  }
-
-  void Post(const EndfileStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EventPostStmt =========== 
-
-  bool Pre(const EventPostStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::EventPost);
-    return true ; 
-  }
-
-  void Post(const EventPostStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== EventWaitStmt =========== 
-
-  bool Pre(const EventWaitStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::EventWait);
-    return true ; 
-  }
-
-  void Post(const EventWaitStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== CycleStmt =========== 
-
-  bool Pre(const CycleStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::Cycle);
-
-    
-    auto & smap = GetStatementMap() ;
-
-    // the optional name of the construct we are looking for. 
-    std::optional<sm::Name> target_name ;
-    if (x.v) {
-      target_name = x.v->ToString();
-    }
-
-    // Reminder: Unlike in EXIT, the target of a CYCLE statement is always 
-    // a DO so the target resolution are similar but not identical.
-    
-    SMap::Index target_do = SMap::None ;    
-    SMap::Index construct = sema.stmt_index ; 
-
-    // Note: At that point, 'construct' refers to the CYCLE statment which 
-    // is not a construct index (i.e. a Start statement). However, in the 
-    // loop below, 'construct' will be assigned a proper construct index. 
-
-    bool done=false ; 
-    while (!done) 
-      {
-        construct = smap.StartOfConstruct(smap.GetParent(construct));
-        assert( smap.GetGroup(construct) == StmtGroup::Start ) ; 
-        auto construct_name = GetConstructName(construct);
-
-        StmtClass construct_class =  smap.GetClass(construct);
-        switch(construct_class) {
-        case StmtClass::LabelDo:
-        case StmtClass::LabelDoWhile:
-        case StmtClass::NonLabelDo:
-        case StmtClass::NonLabelDoWhile:
-          if ( ! target_name ) {
-            // The default target is the first loop
-            target_do = construct;
-            done = true;
-          } else if ( construct_name == target_name ) {
-            target_do = construct;
-            done = true;
-          } 
-          break;
-          
-        case StmtClass::LabelDoConcurrent:
-        case StmtClass::NonLabelDoConcurrent: 
-          // C1135 A cycle-stmt shall not appear within a CHANGE TEAM, CRITICAL, or DO 
-          // CONCURRENT construct if it belongs to an outer construct.
-          //           
-          // Simply speaking, a DO CONCURRENT should either match or fail.
-          //
-          if ( ! target_name ) {
-            // The default target is the first loop
-            target_do = construct;
-            done = true;
-          } else if ( construct_name == target_name ) {
-            target_do = construct;
-            done = true;
-          } else {
-            FAIL("CYCLE statement cannot be used to exit a " << StmtClassText(construct_class) << " statement");
-            done = true;
-          }
-          break;
-
-
-        case StmtClass::ChangeTeam:
-        case StmtClass::Critical:
-          // C1135 A cycle-stmt shall not appear within a CHANGE TEAM, CRITICAL, or DO 
-          // CONCURRENT construct if it belongs to an outer construct.
-          //
-          FAIL("CYCLE statement cannot be used to exit a " << StmtClassText(construct_class) <<  " statement");
-          done = true;
-          break ;
-
-        case StmtClass::IfThen:
-        case StmtClass::SelectCase:
-        case StmtClass::SelectRank:
-        case StmtClass::SelectType:
-        case StmtClass::Block:
-        case StmtClass::Associate:
-        case StmtClass::WhereConstruct: 
-          // A CYCLE statement can be used to exit those constructs but they are proper targets
-          break;
-
-        case StmtClass::Program:
-        case StmtClass::Function:
-        case StmtClass::Subroutine:
-          // We need to stop here. 
-          done = true; 
-          break;
-
-        case StmtClass::If:
-          // This is a non-construct IF that owns the EXIT statement
-          break;
-
-        default:
-          // TODO: If you hit that internal error then that means that
-          // we forgot to handle a construct that is susceptible to 
-          // contain an EXIT statement
-          INTERNAL_ERROR;
-
-        }
-      }
-
-    if ( target_do == SMap::None ) {
-      if ( target_name ) {
-        FAIL("No construct named '" << *target_name << "' found arount CYCLE statement" ) ;
-      } else {
-        FAIL("No loop found arount CYCLE statement" ) ;
-      }
-    }
-    
-    TRACE("Target of CYCLE statement #" << sema.stmt_index << " is statement #" << target_do );
-
-    // TODO: Do something with target_do
-
-    return true ; 
-  }
-
-  void Post(const CycleStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ExitStmt =========== 
-
-  bool Pre(const ExitStmt &x) { 
-    TRACE_CALL() ;
-    auto & sema = InitStmt(x, StmtClass::Exit);
-
-    auto & smap = GetStatementMap() ;
-
-    // the name of the construct we are looking for (can be null)
-    std::optional<sm::Name> target_name;
-    if (x.v) 
-      target_name = x.v->ToString(); 
-
-    // Remark: I am currently search the target construct by 
-    // only considering its identifer but this is actually incorrect
-    // because of scopes.
-    // 
-    // For instance, consider the following piece of code
-    //
-    //  outer: do i=1,n
-    //  inner: do j=1,n
-    //    block
-    //      import, only :: A,i
-    //      outer: do k=1,3
-    //        ...
-    //      enddo outer
-    //      if (A(i)==0) EXIT outer 
-    //      A(i) = 42 
-    //    end block
-    //  enddo inner
-    //  enddo outer
-    //
-    //  The current implemntation would match the i-loop even though
-    //  its name should not be visible because of the IMPORT, ONLY 
-    //  statement.
-    //
-    //  The proper way should be: 
-    //    - resolve the name to an existing symbol 
-    //    - fail is that symbol is not a construct name (by design 
-    //      there is no issue with forward references)
-    //    - and then explore the parent constructs to match their
-    //      respective symbol (stored in the Statement Map?)
-    //  
-    // Remark: if the symbol holds the SIndex of the construct 
-    //   then the match should be done usng that. 
-    //
-    SMap::Index target_construct = SMap::None ;    
-    SMap::Index construct = sema.stmt_index ; 
-
-    // At that point, construct refers to EXIT statment which is not a
-    // construct index (i.e. a Start statement). However, in the loop below, 
-    // it will be assigned a proper construct index. 
-
-    bool done=false ; 
-    while (!done) 
-      {
-        construct = smap.StartOfConstruct(smap.GetParent(construct));
-        assert( smap.GetGroup(construct) == StmtGroup::Start ) ; 
-        auto construct_name = GetConstructName(construct);
-
-        StmtClass construct_class =  smap.GetClass(construct);
-        switch(construct_class) {
-        case StmtClass::LabelDo:
-        case StmtClass::LabelDoWhile:
-        case StmtClass::NonLabelDo:
-        case StmtClass::NonLabelDoWhile:
-          if ( ! target_name ) {
-            // The default target is the first loop
-            target_construct = construct;
-            done = true;
-          } else if ( construct_name == target_name ) {
-            target_construct = construct;
-            done = true;
-          } 
-          break;
-          
-        case StmtClass::LabelDoConcurrent:
-        case StmtClass::NonLabelDoConcurrent: 
-        case StmtClass::ChangeTeam:
-        case StmtClass::Critical:
-          //
-          //  C1167 An exit-stmt shall not appear within a CHANGE TEAM, CRITICAL, or DO CONCURRENT construct
-          //  if it belongs to that construct or an outer construct.
-          //
-          FAIL("EXIT statement cannot be used to exit a " << StmtClassText(construct_class) << " statement");
-          break ;
-
-        case StmtClass::IfThen:
-        case StmtClass::SelectCase:
-        case StmtClass::SelectRank:
-        case StmtClass::SelectType:
-        case StmtClass::Block:
-        case StmtClass::Associate:
-        case StmtClass::WhereConstruct: 
-          // Those constructs that can be 'exited' if explicitly named
-          if ( target_name ) { 
-            if ( construct_name == target_name ) {
-              target_construct = construct;
-              done = true;
-            }
-          } 
-          break;
-
-        case StmtClass::Program:
-        case StmtClass::Function:
-        case StmtClass::Subroutine:
-          // We need to stop here. 
-          done = true; 
-          break;
-
-        case StmtClass::If:
-          // This is a non-construct IF that owns the EXIT statement
-          break;
-
-        default:
-          // TODO: If you hit that internal error then that means that
-          // we forgot to handle a construct that is susceptible to 
-          // contain an EXIT statement
-          INTERNAL_ERROR;
-
-        }
-      }
-
-    if ( target_construct == SMap::None ) {
-      if ( target_name ) {
-        FAIL("No construct named '" << *target_name << "' found arount EXIT statement" ) ;
-      } else {
-        FAIL("No loop found arount EXIT statement" ) ;
-      }
-    }
-    
-    TRACE("Target of EXIT statement #" << sema.stmt_index << " is statement #" << target_construct );
-    // TODO: Do something with target_construct
-
-
-    return true ; 
-  }
-
-  void Post(const ExitStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== FailImageStmt =========== 
-
-  bool Pre(const FailImageStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::FailImage);
-    return true ; 
-  }
-
-  void Post(const FailImageStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== FlushStmt =========== 
-
-  bool Pre(const FlushStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Flush);
-    return true ; 
-  }
-
-  void Post(const FlushStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== FormTeamStmt =========== 
-
-  bool Pre(const FormTeamStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::FormTeam);
-    return true ; 
-  }
-
-  void Post(const FormTeamStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== GotoStmt =========== 
-
-  bool Pre(const GotoStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Goto);
-    return true ; 
-  }
-
-  void Post(const GotoStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== InquireStmt =========== 
-
-  bool Pre(const InquireStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Inquire);
-    return true ; 
-  }
-
-  void Post(const InquireStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== LockStmt =========== 
-
-  bool Pre(const LockStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Lock);
-    return true ; 
-  }
-
-  void Post(const LockStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== NullifyStmt =========== 
-
-  bool Pre(const NullifyStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Nullify);
-    return true ; 
-  }
-
-  void Post(const NullifyStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== OpenStmt =========== 
-
-  bool Pre(const OpenStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Open);
-    return true ; 
-  }
-
-  void Post(const OpenStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== PointerAssignmentStmt =========== 
-
-  bool Pre(const PointerAssignmentStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::PointerAssignment);
-    return true ; 
-  }
-
-  void Post(const PointerAssignmentStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ReadStmt =========== 
-
-  bool Pre(const ReadStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Read);
-    return true ; 
-  }
-
-  void Post(const ReadStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ReturnStmt =========== 
-
-  bool Pre(const ReturnStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Return);
-    return true ; 
-  }
-
-  void Post(const ReturnStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== RewindStmt =========== 
-
-  bool Pre(const RewindStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Rewind);
-    return true ; 
-  }
-
-  void Post(const RewindStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== StmtFunctionStmt =========== 
-
-  bool Pre(const StmtFunctionStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Rewind);
-    return true ; 
-  }
-
-  void Post(const StmtFunctionStmt &x) {     
-    TRACE_CALL() ;
-  }
-  
-  // =========== StopStmt =========== 
-
-  bool Pre(const StopStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Stop);
-    return true ; 
-  }
-
-  void Post(const StopStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== SyncAllStmt =========== 
-
-  bool Pre(const SyncAllStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::SyncAll);
-    return true ; 
-  }
-
-  void Post(const SyncAllStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== SyncImagesStmt =========== 
-
-  bool Pre(const SyncImagesStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::SyncImages);
-    return true ; 
-  }
-
-  void Post(const SyncImagesStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== SyncMemoryStmt =========== 
-
-  bool Pre(const SyncMemoryStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::SyncMemory);
-    return true ; 
-  }
-
-  void Post(const SyncMemoryStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== SyncTeamStmt =========== 
-
-  bool Pre(const SyncTeamStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::SyncTeam);
-    return true ; 
-  }
-
-  void Post(const SyncTeamStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== UnlockStmt =========== 
-
-  bool Pre(const UnlockStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Unlock);
-    return true ; 
-  }
-
-  void Post(const UnlockStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== WaitStmt =========== 
-
-  bool Pre(const WaitStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Wait);
-    return true ; 
-  }
-
-  void Post(const WaitStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== WhereStmt =========== 
-
-  bool Pre(const WhereStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Where);
-    return true ; 
-  }
-
-  void Post(const WhereStmt &x) { 
-    TRACE_CALL() ;
-    GetStatementMap().Add( StmtClass::DummyEndWhere, 0); 
-  }
-
-  // =========== WriteStmt =========== 
-
-  bool Pre(const WriteStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Write);
-    return true ; 
-  }
-
-  void Post(const WriteStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ComputedGotoStmt =========== 
-
-  bool Pre(const ComputedGotoStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::ComputedGoto);
-    return true ; 
-  }
-
-  void Post(const ComputedGotoStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== ForallStmt =========== 
-
-  bool Pre(const ForallStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Forall);
-    return true ; 
-  }
-
-  void Post(const ForallStmt &x) { 
-    TRACE_CALL() ;
-    GetStatementMap().Add( StmtClass::DummyEndForall, 0); 
-  }
-
-  // =========== ArithmeticIfStmt =========== 
-
-  bool Pre(const ArithmeticIfStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::ArithmeticIf);
-    return true ; 
-  }
-
-  void Post(const ArithmeticIfStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== AssignStmt =========== 
-
-  bool Pre(const AssignStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Assign);
-    
-    return true ; 
-  }
-
-  void Post(const AssignStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== AssignedGotoStmt =========== 
-
-  bool Pre(const AssignedGotoStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::AssignedGoto);
-    return true ; 
-  }
-
-  void Post(const AssignedGotoStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== PauseStmt =========== 
-
-  bool Pre(const PauseStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Pause);
-    return true ; 
-  }
-
-  void Post(const PauseStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== PrivateStmt =========== 
-
-  bool Pre(const PrivateStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::Private);
-    return true ; 
-  }
-
-  void Post(const PrivateStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-  // =========== TypeBoundProcedureStmt =========== 
-
-  bool Pre(const TypeBoundProcedureStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::TypeBoundProcedure);
-    return true ; 
-  }
-
-  void Post(const TypeBoundProcedureStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-
-  // =========== FinalProcedureStmt =========== 
-
-  bool Pre(const FinalProcedureStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::FinalProcedure);
-    return true ; 
-  }
-
-  void Post(const FinalProcedureStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-
-  // =========== TypeBoundGenericStmt =========== 
-
-  bool Pre(const TypeBoundGenericStmt &x) { 
-    TRACE_CALL() ;
-    InitStmt(x, StmtClass::TypeBoundGeneric);
-    return true ; 
-  }
-
-  void Post(const TypeBoundGenericStmt &x) { 
-    TRACE_CALL() ;
-  }
-
-
-
-public:
-  
-  void run(const ProgramUnit &p) {  
-    assert( NoLabelTable() ) ; 
-    current_scope_ = unit_scope_;
-    Walk(p,*this) ;
-    assert( current_scope_ == unit_scope_ ) ;
-  }
-
-} ;
-
-}  // of namespace Fortran::parser 
-
-
-void DoSemanticAnalysis( const psr::CookedSource & source,const psr::Program &all) 
-{ 
-  psr::Pass1 pass1(source) ;
-  for (const psr::ProgramUnit &unit : all.v) {
-    TRACE("===========================================================================================================");
-    psr::DumpTree(unit);
-    TRACE("===========================================================================================================");
-    pass1.run(unit) ; 
-  } 
-}
-
diff --git a/flang/tools/f18/test-sema.cc b/flang/tools/f18/test-sema.cc
deleted file mode 100644
index f1a7395b0588..000000000000
--- a/flang/tools/f18/test-sema.cc
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "../../lib/parser/parsing.h"
-#include "../../lib/semantics/attr.h"
-#include "../../lib/semantics/type.h"
-#include <cstdlib>
-#include <iostream>
-#include <list>
-#include <optional>
-#include <sstream>
-#include <stddef.h>
-#include <string>
-
-using namespace Fortran;
-using namespace parser;
-
-extern void DoSemanticAnalysis(const CookedSource &, const Program &);
-
-//static void visitProgramUnit(const ProgramUnit &unit);
-
-int main(int argc, char *const argv[]) {
-  if (argc != 2) {
-    std::cerr << "Expected 1 source file, got " << (argc - 1) << "\n";
-    return EXIT_FAILURE;
-  }
-  std::string path{argv[1]};
-  Parsing parsing;
-  if (parsing.ForTesting(path, std::cerr)) {
-    DoSemanticAnalysis(parsing.cooked(), *parsing.parseTree());
-    return EXIT_SUCCESS;
-  }
-  return EXIT_FAILURE;
-}