[flang] New implementation for checks for constraints C741 through C750

[PeteSteinfeld]

Summary

Most of this was previously in review in D78160. Since that last review, I
added an enumeration to distinguish between specification expressions for
component bounds and for type parameters. I then changed the code to pass an
enumeration value to "CheckSpecificationExpr()" to indicate that the expression
was a bounds expression and used this value to determine whether to emit an
error message when violations of C750 are found.

Here's the information about the overall changes in the previous review:

Most of these checks were already implemented, and I just added references to
them to the code and tests. Also, much of this code was already
reviewed in the old flang/f18 GitHub repository, but I didn't get to
merge it before we switched repositories.

I implemented the check for C747 to not allow coarray components in derived
types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE.

I implemented the check for C748 that requires a data component whose type has
a coarray ultimate component to be a nonpointer, nonallocatable scalar and not
be a coarray.

I implemented the check for C750 that adds additional restrictions to the
bounds expressions of a derived type component that's an array. C750 prohibits
specification functions, the intrinsic functions ALLOCATED, ASSOCIATED,
EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every
specification inquiry reference to be a constant expression, and requires that
the value of the bound not depend on the value of a variable. To do this, I
added code to the intrinsic proc table to get the intrinsic class of a
procedure.

I changed the implementation of IsPureProcedure() to handle statement functions
and changed some references in the code that tested for the PURE attribute to
call IsPureProcedure().

I also fixed some unrelated tests that got new errors when I implemented these
new checks.

[tskeith]

flang/include/flang/Evaluate/check-expression.h

55

const is meaningless in const SpecificationExprContext.

[PeteSteinfeld]

flang/include/flang/Evaluate/check-expression.h

55

Thanks, Tim. I'll remove it.

[PeteSteinfeld]

Response to review comments

Removed an unnecessary "const" as per Tim's recommendation.

flang/include/flang/Evaluate/check-expression.h

 // bounds and type param expressions.  We need to differentiate them because
 // additional checks are required for array bounds expressions in declarations
 // of derived type components (see C750).
 ENUM_CLASS(SpecificationExprContext, TYPE_PARAM, BOUND)
 
 template <typename A>
 void CheckSpecificationExpr(const A &, parser::ContextualMessages &,
     const semantics::Scope &, const IntrinsicProcTable &,
     SpecificationExprContext);
 extern template void CheckSpecificationExpr(const Expr<SomeType> &x,
     parser::ContextualMessages &, const semantics::Scope &,
-    const IntrinsicProcTable &, const SpecificationExprContext);
+    const IntrinsicProcTable &, SpecificationExprContext);
 extern template void CheckSpecificationExpr(const Expr<SomeInteger> &x,
     parser::ContextualMessages &, const semantics::Scope &,
-    const IntrinsicProcTable &, const SpecificationExprContext);
+    const IntrinsicProcTable &, SpecificationExprContext);
 extern template void CheckSpecificationExpr(const Expr<SubscriptInteger> &x,
     parser::ContextualMessages &, const semantics::Scope &,
-    const IntrinsicProcTable &, const SpecificationExprContext);
+    const IntrinsicProcTable &, SpecificationExprContext);
 extern template void CheckSpecificationExpr(
     const std::optional<Expr<SomeType>> &x, parser::ContextualMessages &,
     const semantics::Scope &, const IntrinsicProcTable &,
-    const SpecificationExprContext);
+    SpecificationExprContext);
 extern template void CheckSpecificationExpr(
     const std::optional<Expr<SomeInteger>> &x, parser::ContextualMessages &,
     const semantics::Scope &, const IntrinsicProcTable &,
-    const SpecificationExprContext);
+    SpecificationExprContext);
 extern template void CheckSpecificationExpr(
     const std::optional<Expr<SubscriptInteger>> &x,
     parser::ContextualMessages &, const semantics::Scope &,
-    const IntrinsicProcTable &, const SpecificationExprContext);
+    const IntrinsicProcTable &, SpecificationExprContext);
 
 // Simple contiguity (9.5.4)
 template <typename A>
 bool IsSimplyContiguous(const A &, const IntrinsicProcTable &);
 extern template bool IsSimplyContiguous(
     const Expr<SomeType> &, const IntrinsicProcTable &);
 
 } // namespace Fortran::evaluate
 #endif

flang/lib/Evaluate/check-expression.cpp

void CheckSpecificationExpr(const A &x, parser::ContextualMessages &messages,
   if (auto why{
           CheckSpecificationExprHelper{scope, table, specExprContext}(x)}) {
     messages.Say("Invalid specification expression: %s"_err_en_US, *why);
   }
 }
 
 template void CheckSpecificationExpr(const Expr<SomeType> &,
     parser::ContextualMessages &, const semantics::Scope &,
-    const IntrinsicProcTable &, const SpecificationExprContext);
+    const IntrinsicProcTable &, SpecificationExprContext);
 template void CheckSpecificationExpr(const Expr<SomeInteger> &,
     parser::ContextualMessages &, const semantics::Scope &,
-    const IntrinsicProcTable &, const SpecificationExprContext);
+    const IntrinsicProcTable &, SpecificationExprContext);
 template void CheckSpecificationExpr(const Expr<SubscriptInteger> &,
     parser::ContextualMessages &, const semantics::Scope &,
-    const IntrinsicProcTable &, const SpecificationExprContext);
+    const IntrinsicProcTable &, SpecificationExprContext);
 template void CheckSpecificationExpr(const std::optional<Expr<SomeType>> &,
     parser::ContextualMessages &, const semantics::Scope &,
-    const IntrinsicProcTable &, const SpecificationExprContext);
+    const IntrinsicProcTable &, SpecificationExprContext);
 template void CheckSpecificationExpr(const std::optional<Expr<SomeInteger>> &,
     parser::ContextualMessages &, const semantics::Scope &,
-    const IntrinsicProcTable &, const SpecificationExprContext);
+    const IntrinsicProcTable &, SpecificationExprContext);
 template void CheckSpecificationExpr(
     const std::optional<Expr<SubscriptInteger>> &, parser::ContextualMessages &,
     const semantics::Scope &, const IntrinsicProcTable &,
-    const SpecificationExprContext);
+    SpecificationExprContext);
 
 // IsSimplyContiguous() -- 9.5.4
 class IsSimplyContiguousHelper
     : public AnyTraverse<IsSimplyContiguousHelper, std::optional<bool>> {
 public:
   using Result = std::optional<bool>; // tri-state
   using Base = AnyTraverse<IsSimplyContiguousHelper, Result>;
   explicit IsSimplyContiguousHelper(const IntrinsicProcTable &t)