Removed the old way to integrate copy-in/copy-out check

Author: eugeneepshteyn

flang/include/flang/Evaluate/call.h

@@ -52,7 +52,7 @@ using SymbolRef = common::Reference<const Symbol>;
 
 class ActualArgument {
 public:
-  ENUM_CLASS(Attr, PassedObject, PercentVal, PercentRef, CopyIn, CopyOut);
+  ENUM_CLASS(Attr, PassedObject, PercentVal, PercentRef);
   using Attrs = common::EnumSet<Attr, Attr_enumSize>;
 
   // Dummy arguments that are TYPE(*) can be forwarded as actual arguments.
@@ -131,6 +131,7 @@ class ActualArgument {
     return *this;
   }
 
+  bool Matches(const characteristics::DummyArgument &) const;
   common::Intent dummyIntent() const { return dummyIntent_; }
   ActualArgument &set_dummyIntent(common::Intent intent) {
     dummyIntent_ = intent;
@@ -160,20 +161,6 @@ class ActualArgument {
     return *this;
   }
 
-  // This actual argument may need copy-in before the procedure call
-  bool GetMayNeedCopyIn() const { return attrs_.test(Attr::CopyIn); };
-  ActualArgument &SetMayNeedCopyIn() {
-    attrs_ = attrs_ + Attr::CopyIn;
-    return *this;
-  }
-
-  // This actual argument may need copy-out after the procedure call
-  bool GetMayNeedCopyOut() const { return attrs_.test(Attr::CopyOut); };
-  ActualArgument &SetMayNeedCopyOut() {
-    attrs_ = attrs_ + Attr::CopyOut;
-    return *this;
-  }
-
 private:
   // Subtlety: There is a distinction that must be maintained here between an
   // actual argument expression that is a variable and one that is not,
@@ -285,8 +272,6 @@ class ProcedureRef {
   bool operator==(const ProcedureRef &) const;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
-  void DetermineCopyInOut();
-
 protected:
   ProcedureDesignator proc_;
   ActualArguments arguments_;

flang/lib/Evaluate/call.cpp

@@ -12,7 +12,6 @@
 #include "flang/Evaluate/check-expression.h"
 #include "flang/Evaluate/expression.h"
 #include "flang/Evaluate/tools.h"
-#include "flang/Semantics/semantics.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Support/Fortran.h"
 
@@ -248,199 +247,4 @@ ProcedureRef::~ProcedureRef() {}
 
 void ProcedureRef::Deleter(ProcedureRef *p) { delete p; }
 
-// We don't know the dummy argument info (e.g., procedure with implicit
-// interface
-static void DetermineCopyInOutArgument(
-    const characteristics::Procedure &procInfo, ActualArgument &actual,
-    semantics::SemanticsContext &sc) {
-  if (actual.isAlternateReturn()) {
-    return;
-  }
-  if (!evaluate::IsVariable(actual)) {
-    // Actual argument expressions that aren’t variables are copy-in, but
-    // not copy-out.
-    actual.SetMayNeedCopyIn();
-  } else if (bool actualIsArray{actual.Rank() > 0};
-      actualIsArray && !IsSimplyContiguous(actual, sc.foldingContext())) {
-    // Actual arguments that are variables are copy-in when non-contiguous.
-    // They are copy-out when don't have vector subscripts
-    actual.SetMayNeedCopyIn();
-    if (!HasVectorSubscript(actual)) {
-      actual.SetMayNeedCopyOut();
-    }
-  } else if (ExtractCoarrayRef(actual)) {
-    // Coindexed actual args need copy-in and copy-out
-    actual.SetMayNeedCopyIn();
-    actual.SetMayNeedCopyOut();
-  }
-}
-
-static void DetermineCopyInOutArgument(
-    const characteristics::Procedure &procInfo, ActualArgument &actual,
-    characteristics::DummyArgument &dummy, semantics::SemanticsContext &sc) {
-  assert(procInfo.HasExplicitInterface() && "expect explicit interface proc");
-  if (actual.isAlternateReturn()) {
-    return;
-  }
-  if (!evaluate::IsVariable(actual)) {
-    // Actual argument expressions that aren’t variables are copy-in, but
-    // not copy-out.
-    actual.SetMayNeedCopyIn();
-    return;
-  }
-  const auto *dummyObj{std::get_if<characteristics::DummyDataObject>(&dummy.u)};
-  if (!dummyObj) {
-    // Only DummyDataObject has the information we need
-    return;
-  }
-  // Pass by value, always copy-in, never copy-out
-  bool dummyIsValue{
-      dummyObj->attrs.test(characteristics::DummyDataObject::Attr::Value)};
-  if (dummyIsValue) {
-    actual.SetMayNeedCopyIn();
-    return;
-  }
-  // All the checks below are for arrays
-
-  bool actualIsAssumedRank{evaluate::IsAssumedRank(actual)};
-  bool actualIsArray{actualIsAssumedRank || actual.Rank() > 0};
-  bool dummyIsAssumedRank{dummyObj->type.attrs().test(
-      characteristics::TypeAndShape::Attr::AssumedRank)};
-  bool dummyIsArray{dummyIsAssumedRank || dummyObj->type.Rank() > 0};
-  bool treatDummyScalarAsArray{dummyObj->type.Rank() == 0 &&
-      dummyObj->ignoreTKR.test(common::IgnoreTKR::Rank)};
-  if (!actualIsArray || !(dummyIsArray || treatDummyScalarAsArray)) {
-    return;
-  }
-
-  bool dummyIntentIn{dummyObj->intent == common::Intent::In};
-  bool dummyIntentOut{dummyObj->intent == common::Intent::Out};
-  auto setCopyIn = [&]() {
-    if (!dummyIntentOut) {
-      // INTENT(OUT) dummy args never need copy-in
-      actual.SetMayNeedCopyIn();
-    }
-  };
-  auto setCopyOut = [&]() {
-    if (!dummyIntentIn) {
-      // INTENT(IN) dummy args never need copy-out
-      actual.SetMayNeedCopyOut();
-    }
-  };
-
-  // Check actual contiguity, unless dummy doesn't care
-  bool actualTreatAsContiguous{
-      dummyObj->ignoreTKR.test(common::IgnoreTKR::Contiguous) ||
-      IsSimplyContiguous(actual, sc.foldingContext())};
-  bool actualHasVectorSubscript{HasVectorSubscript(actual)};
-  bool dummyIsExplicitShape{dummyObj->type.IsExplicitShape()};
-  bool dummyIsAssumedSize{dummyObj->type.attrs().test(
-      characteristics::TypeAndShape::Attr::AssumedSize)};
-  bool dummyIsPolymorphic{dummyObj->type.type().IsPolymorphic()};
-  // Explicit shape and assumed size arrays must be contiguous
-  bool dummyNeedsContiguity{dummyIsExplicitShape || dummyIsAssumedSize ||
-      // Polymorphic dummy is descriptor based, so should be able to handle
-      // discontigunity.
-      (treatDummyScalarAsArray && !dummyIsPolymorphic) ||
-      dummyObj->attrs.test(characteristics::DummyDataObject::Attr::Contiguous)};
-  if (!actualTreatAsContiguous && dummyNeedsContiguity) {
-    setCopyIn();
-    // Cannot do copy-out for vector subscripts: there could be repeated
-    // indices, for example
-    if (!actualHasVectorSubscript) {
-      setCopyOut();
-    }
-    return;
-  }
-
-  bool dummyIsAssumedShape{dummyObj->type.attrs().test(
-      characteristics::TypeAndShape::Attr::AssumedShape)};
-  bool actualIsAssumedShape{IsAssumedShape(actual)};
-  if ((actualIsAssumedRank && dummyIsAssumedRank) ||
-      (actualIsAssumedShape && dummyIsAssumedShape)) {
-    // Assumed-rank and assumed-shape arrays are represented by descriptors,
-    // so don't need to do polymorphic check.
-  } else if (!dummyObj->ignoreTKR.test(common::IgnoreTKR::Type)) {
-    // flang supports limited cases of passing polymorphic to non-polimorphic.
-    // These cases require temporary of non-polymorphic type. (For example,
-    // the actual argument could be polymorphic array of child type,
-    // while the dummy argument could be non-polymorphic array of parent type.)
-    auto actualType{characteristics::TypeAndShape::Characterize(
-        actual, sc.foldingContext())};
-    bool actualIsPolymorphic{actualType->type().IsPolymorphic()};
-    if (actualIsPolymorphic && !dummyIsPolymorphic) {
-      setCopyIn();
-      setCopyOut();
-    }
-  }
-}
-
-void ProcedureRef::DetermineCopyInOut() {
-  if (!proc_.GetSymbol()) {
-    return;
-  }
-  // Get folding context of the call site owner
-  semantics::SemanticsContext &sc{proc_.GetSymbol()->owner().context()};
-  FoldingContext &fc{sc.foldingContext()};
-  auto procInfo{
-      characteristics::Procedure::Characterize(proc_, fc, /*emitError=*/true)};
-  if (!procInfo) {
-    return;
-  }
-  if (!procInfo->HasExplicitInterface()) {
-    for (auto &actual : arguments_) {
-      if (!actual) {
-        continue;
-      }
-      DetermineCopyInOutArgument(*procInfo, *actual, sc);
-    }
-    return;
-  }
-  // Don't change anything about actual or dummy arguments, except for
-  // computing copy-in/copy-out information. If detect something wrong with
-  // the arguments, stop processing and let semantic analysis generate the
-  // error messages.
-  size_t index{0};
-  std::set<std::string> processedKeywords;
-  bool seenKeyword{false};
-  for (auto &actual : arguments_) {
-    if (!actual) {
-      continue;
-    }
-    if (index >= procInfo->dummyArguments.size()) {
-      // More actual arguments than dummy arguments. Semantic analysis will
-      // deal with the error.
-      return;
-    }
-    if (actual->keyword()) {
-      seenKeyword = true;
-      auto actualName{actual->keyword()->ToString()};
-      if (processedKeywords.find(actualName) != processedKeywords.end()) {
-        // Actual arguments with duplicate keywords. Semantic analysis will
-        // deal with the error.
-        return;
-      } else {
-        processedKeywords.insert(actualName);
-        if (auto it{std::find_if(procInfo->dummyArguments.begin(),
-                procInfo->dummyArguments.end(),
-                [&](const characteristics::DummyArgument &dummy) {
-                  return dummy.name == actualName;
-                })};
-            it != procInfo->dummyArguments.end()) {
-          DetermineCopyInOutArgument(*procInfo, *actual, *it, sc);
-        }
-      }
-    } else if (seenKeyword) {
-      // Non-keyword actual argument after have seen at least one keyword
-      // actual argument. Semantic analysis will deal with the error.
-      return;
-    } else {
-      // Positional argument processing
-      DetermineCopyInOutArgument(
-          *procInfo, *actual, procInfo->dummyArguments[index], sc);
-    }
-    ++index;
-  }
-}
-
 } // namespace Fortran::evaluate

flang/lib/Semantics/expression.cpp

@@ -3464,7 +3464,6 @@ void ExpressionAnalyzer::Analyze(const parser::CallStmt &callStmt) {
                 HasAlternateReturns(callee->arguments)},
             ProcedureRef::Deleter);
         DEREF(callStmt.typedCall.get()).set_chevrons(std::move(*chevrons));
-        DEREF(callStmt.typedCall.get()).DetermineCopyInOut();
         return;
       }
     }
@@ -4389,7 +4388,6 @@ MaybeExpr ExpressionAnalyzer::MakeFunctionRef(parser::CharBlock callSite,
     if (chars->functionResult) {
       const auto &result{*chars->functionResult};
       ProcedureRef procRef{std::move(proc), std::move(arguments)};
-      procRef.DetermineCopyInOut();
       if (result.IsProcedurePointer()) {
         return Expr<SomeType>{std::move(procRef)};
       } else {