[flang][msvc] Avoid ReferenceVariantBase ctor ambiguity. NFC.

[Meinersbur]

Summary

Msvc reports the following error when a ReferenceVariantBase is constructed using an r-value reference or instantiated as std::vector template parameter. The error message is:

PFTBuilder.h(59,1): error C2665: 'std::variant<...>::variant': none of the 2 overloads could convert all the argument types
variant(1248,1): message : could be 'std::variant<...>::variant(std::variant<...> &&) noexcept(false)'
variant(1248,1): message : or       'std::variant<...>::variant(const std::variant<...> &) noexcept(false)'
PFTBuilder.h(59,1): message : while trying to match the argument list '(common::Reference<lower::pft::ReferenceVariantBase<false,...>>)'

Work around the ambiguity by only taking common::Reference arguments in the constructor. That is, conversion to common::Reference has to be done be the caller instead of being done inside the ctor. Unfortunately, with this change clang/gcc (but not msvc) insist on that the ReferenceVariantBase is stored in a std::initializer_list-initialized variable before being used, like being passed to a function or returned.

This patch is part of the series to make flang compilable with MS Visual Studio http://lists.llvm.org/pipermail/flang-dev/2020-July/000448.html.

[Meinersbur]

Microsoft bug report: https://developercommunity.visualstudio.com/content/problem/1193950/ambiguous-constructor-in-vector-copy.html

[Meinersbur]

• Adhere flang variable naming scheme

[Meinersbur]

• Adhere clang variable naming scheme

[DavidTruby]

LGTM. Not sure why msvc thinks these are ambiguous

[Meinersbur]

• Compile fix (forgotten rename)

flang/include/flang/Lower/PFTBuilder.h

 //===-- Lower/PFTBuilder.h -- PFT builder -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 class ReferenceVariantBase {
 public:
   template <typename B>
   using BaseType = std::conditional_t<isConst, const B, B>;
   template <typename B>
   using Ref = common::Reference<BaseType<B>>;
 
   ReferenceVariantBase() = delete;
-  template <typename B>
-  ReferenceVariantBase(B &b) : u{Ref<B>{b}} {}
+  ReferenceVariantBase(std::variant<Ref<A>...> b) : u(b) {}
+  template <typename T>
+  ReferenceVariantBase(Ref<T> b) : u(b) {}
 
   template <typename B>
   constexpr BaseType<B> &get() const {
     return std::get<Ref<B>> > (u).get();
   }
   template <typename B>
   constexpr BaseType<B> *getIf() const {
     auto *ptr = std::get_if<Ref<B>>(&u);

flang/lib/Lower/PFTBuilder.cpp

 //===-- PFTBuilder.cc -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 };
 
 /// The instantiation of a parse tree visitor (Pre and Post) is extremely
 /// expensive in terms of compile and link time.  So one goal here is to
 /// limit the bridge to one such instantiation.
 class PFTBuilder {
 public:
   PFTBuilder(const semantics::SemanticsContext &semanticsContext)
-      : pgm{std::make_unique<lower::pft::Program>()},
-        parentVariantStack{*pgm.get()}, semanticsContext{semanticsContext} {}
+      : pgm{std::make_unique<lower::pft::Program>()}, semanticsContext{
+                                                          semanticsContext} {
+    lower::pft::ParentVariant y{*pgm.get()};
+    parentVariantStack.push_back(y);
+  }
 
   /// Get the result
   std::unique_ptr<lower::pft::Program> result() { return std::move(pgm); }
 
   template <typename A>
   constexpr bool Pre(const A &a) {
     if constexpr (lower::pft::isFunctionLike<A>) {
       return enterFunction(a, semanticsContext);
private:
   std::size_t nextIndex{1}; // 0 is the root
 };
 
 } // namespace
 
 template <typename A, typename T>
 static lower::pft::FunctionLikeUnit::FunctionStatement
 getFunctionStmt(const T &func) {
-  return std::get<parser::Statement<A>>(func.t);
+  lower::pft::FunctionLikeUnit::FunctionStatement result{
+      std::get<parser::Statement<A>>(func.t)};
+  return Res;
 }
 template <typename A, typename T>
 static lower::pft::ModuleLikeUnit::ModuleStatement getModuleStmt(const T &mod) {
-  return std::get<parser::Statement<A>>(mod.t);
+  lower::pft::ModuleLikeUnit::ModuleStatement result{
+      std::get<parser::Statement<A>>(mod.t)};
+  return Res;
 }
 
 static const semantics::Symbol *getSymbol(
     std::optional<lower::pft::FunctionLikeUnit::FunctionStatement> &beginStmt) {
   if (!beginStmt)
     return nullptr;
 
   const auto *symbol = beginStmt->visit(common::visitors{
Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
     const parser::MainProgram &func, const lower::pft::ParentVariant &parent,
     const semantics::SemanticsContext &semanticsContext)
     : ProgramUnit{func, parent}, endStmt{
                                      getFunctionStmt<parser::EndProgramStmt>(
                                          func)} {
   const auto &ps{
       std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(func.t)};
   if (ps.has_value()) {
-    beginStmt = ps.value();
+    FunctionStatement begin{ps.value()};
+    beginStmt = begin;
     symbol = getSymbol(beginStmt);
     processSymbolTable(*symbol->scope());
   } else {
     processSymbolTable(semanticsContext.FindScope(
         std::get<parser::Statement<parser::EndProgramStmt>>(func.t).source));
   }
 }