[flang] Checks for constraints C741 through C750

[PeteSteinfeld]

Summary

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.

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/lib/Evaluate/check-expression.cpp

263

This test and the one above only work if there are no other intrinsics that can be returned by GetSpecificIntrinsic whose names are not substrings of one of the names in the string. For example, if intrin.name is "max", it will find it in inquiryIntrinsics.

It seems like a set would be a better representation than a string. Or maybe an addition to the intrinsics table?

flang/lib/Semantics/tools.cpp

277

If symbol is a statement function it must have SubprogramDetails. So you can use symbol.get<SubprogramDetails>() instead.

flang/test/Semantics/resolve88.f90

50

Why is "when an allocatable object is a coarray" here but not in the TEAM_TYPE message?

68

Why '%goodcoarrayfield' rather than 'goodcoarrayfield'?

72

There is an extra space between "coarray" and "ultimate".

[sscalpone]

flang/lib/Evaluate/check-expression.cpp

263

+1 an addition to the intrinsics table

[PeteSteinfeld]

flang/lib/Evaluate/check-expression.cpp

263

Good point. Certainly a set would be better. I'll look into adding a couple of methods to the intrinsics table to cover these two cases.

flang/lib/Semantics/tools.cpp

277

Thanks. I'll change that.

flang/test/Semantics/resolve88.f90

50

Good question. I'll make the two messages consistent.

68

The "%" is meant to indicate that the name is the name of a component. The code to create this message relies on the function "BuildResultDesignatorName()", which inserts the "%". I assume that the other uses of this function are creating compound names that include the name of the derived type object followed the "%" and the field name. I wasn't sure how to treat this. This "%" adds a little information in that it is a hint that the name is a component name, but as both you and I noticed, it's also confusing. I'll get rid of it.

72

Thanks. I'll fix that.

[PeteSteinfeld]

• Merge branch 'master' of https://github.com/llvm/llvm-project
• Responses to review comments.

I changed the test to see if a function is in intrinsic inquiry function from a
string comparison to a more general capability in the intrinsic proc table to
get the intrinsic class of a procedure.

I changed the test for intrinsics specific that are prohibited from use
specifically in derived type component bound declarations to be a set of
strings.

I changed the implementation of IsPureProcedure() to get the associated
symbol's SubprogramDetails to check for references to PURE procedures and
VOLATILE variables.

I made the error messages for bad declarations of derived type components to be
more consistent.

I removed the "%" in front of the component name in error messages relating to
bad component declarations.

I noticed that C750 prohibits non-constant specification inquiries and added a
test for specification inquiries that are type parameter inquiries which are
defined in 9.4.5. I added a test for this case, which caused me to change the
implementation of "IsConstantExpr()" for "TypeParamInquiry"s and symbols.
Specifically, I now require that individual parts of a "TypeParamInquiry" to be
constant. I also call a component of a derived type constant since the overall
"constant"ness of the expression will be determined by the enclosing derived
type object.

In the process of implementing this, I noticed that we really need a predicate
function to determine if an expression is a specification inquiry as defined in
10.1.11(5). But I decided to defer the implementation of such a predicate to
later.

[tskeith]

flang/test/Semantics/assign04.f90

9

Are the changes to this file intentional? They don't seem related to your changes.

[PeteSteinfeld]

flang/test/Semantics/assign04.f90

9

I changed the implementation of "IsConstantExpr" in lib/Evaluate/check-expression.cpp to say that symbols that are components are constants. That change caused this test to emit different error messages for these two cases.

Previously, a symbol was only declared as a constant if it had the PARAMETER attribute or was an implied DO index. My reasoning is that the derived type object establishes whether the expression is constant. The problem I was trying to solve is that we were always treating expressions like "a%b" as non-constant even if "a" was a constant.

[PeteSteinfeld]

This review is superseded by D79263.

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

 //===-- include/flang/Evaluate/check-expression.h ---------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 // Static expression checking
 
 #ifndef FORTRAN_EVALUATE_CHECK_EXPRESSION_H_
 #define FORTRAN_EVALUATE_CHECK_EXPRESSION_H_
 
 #include "expression.h"
+#include "intrinsics.h"
 #include "type.h"
 #include <optional>
 
 namespace Fortran::parser {
 class ContextualMessages;
 }
 namespace Fortran::semantics {
 class Scope;

 // Checks whether an expression is an object designator with
 // constant addressing and no vector-valued subscript.
 bool IsInitialDataTarget(const Expr<SomeType> &, parser::ContextualMessages &);
 
 // Check whether an expression is a specification expression
 // (10.1.11(2), C1010).  Constant expressions are always valid
 // specification expressions.
 template <typename A>
-void CheckSpecificationExpr(
-    const A &, parser::ContextualMessages &, const semantics::Scope &);
+void CheckSpecificationExpr(const A &, parser::ContextualMessages &,
+    const semantics::Scope &, const IntrinsicProcTable &);
 extern template void CheckSpecificationExpr(const Expr<SomeType> &x,
-    parser::ContextualMessages &, const semantics::Scope &);
+    parser::ContextualMessages &, const semantics::Scope &,
+    const IntrinsicProcTable &);
 extern template void CheckSpecificationExpr(const Expr<SomeInteger> &x,
-    parser::ContextualMessages &, const semantics::Scope &);
+    parser::ContextualMessages &, const semantics::Scope &,
+    const IntrinsicProcTable &);
 extern template void CheckSpecificationExpr(const Expr<SubscriptInteger> &x,
-    parser::ContextualMessages &, const semantics::Scope &);
+    parser::ContextualMessages &, const semantics::Scope &,
+    const IntrinsicProcTable &);
 extern template void CheckSpecificationExpr(
     const std::optional<Expr<SomeType>> &x, parser::ContextualMessages &,
-    const semantics::Scope &);
+    const semantics::Scope &, const IntrinsicProcTable &);
 extern template void CheckSpecificationExpr(
     const std::optional<Expr<SomeInteger>> &x, parser::ContextualMessages &,
-    const semantics::Scope &);
+    const semantics::Scope &, const IntrinsicProcTable &);
 extern template void CheckSpecificationExpr(
     const std::optional<Expr<SubscriptInteger>> &x,
-    parser::ContextualMessages &, const semantics::Scope &);
+    parser::ContextualMessages &, const semantics::Scope &,
+    const IntrinsicProcTable &);
 
 // 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/include/flang/Evaluate/intrinsics.h

SpecificIntrinsicFunctionInterface(
       : characteristics::Procedure{std::move(p)}, genericName{n},
         isRestrictedSpecific{isRestrictedSpecific} {}
   std::string genericName;
   bool isRestrictedSpecific;
   // N.B. If there are multiple arguments, they all have the same type.
   // All argument and result types are intrinsic types with default kinds.
 };
 
+// Generic intrinsic classes from table 16.1
+ENUM_CLASS(IntrinsicClass, atomicSubroutine, collectiveSubroutine,
+    elementalFunction, elementalSubroutine, inquiryFunction, pureSubroutine,
+    impureSubroutine, transformationalFunction, noClass)
+
 class IntrinsicProcTable {
 private:
   class Implementation;
 
 public:
   ~IntrinsicProcTable();
   static IntrinsicProcTable Configure(
       const common::IntrinsicTypeDefaultKinds &);
 
   // Check whether a name should be allowed to appear on an INTRINSIC
   // statement.
   bool IsIntrinsic(const std::string &) const;
 
+  // Inquiry intrinsics are defined in section 16.7, table 16.1
+  IntrinsicClass GetIntrinsicClass(const std::string &) const;
+
   // Probe the intrinsics for a match against a specific call.
   // On success, the actual arguments are transferred to the result
   // in dummy argument order; on failure, the actual arguments remain
   // untouched.
   std::optional<SpecificCall> Probe(
       const CallCharacteristics &, ActualArguments &, FoldingContext &) const;
 
   // Probe the intrinsics with the name of a potential specific intrinsic.

flang/lib/Evaluate/check-expression.cpp

 //===-- lib/Evaluate/check-expression.cpp ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Evaluate/check-expression.h"
+#include "flang/Evaluate/intrinsics.h"
 #include "flang/Evaluate/traverse.h"
 #include "flang/Evaluate/type.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
+#include <set>
+#include <string>
 
 namespace Fortran::evaluate {
 
 // Constant expression predicate IsConstantExpr().
 // This code determines whether an expression is a "constant expression"
 // in the sense of section 10.1.12.  This is not the same thing as being
 // able to fold it (yet) into a known constant value; specifically,
 // the expression may reference derived type kind parameters whose values
 // are not yet known.
 class IsConstantExprHelper : public AllTraverse<IsConstantExprHelper, true> {
 public:
   using Base = AllTraverse<IsConstantExprHelper, true>;
   IsConstantExprHelper() : Base{*this} {}
   using Base::operator();
 
   template <int KIND> bool operator()(const TypeParamInquiry<KIND> &inq) const {
-    return IsKindTypeParameter(inq.parameter());
+    return IsConstantExpr(inq.parameter()) && IsConstantExpr(inq.base());
   }
+  // Components are constant if their parent derived type object is
   bool operator()(const semantics::Symbol &symbol) const {
-    return IsNamedConstant(symbol) || IsImpliedDoIndex(symbol);
+    return IsNamedConstant(symbol) || IsImpliedDoIndex(symbol) ||
+        symbol.owner().IsDerivedType();
   }
   bool operator()(const CoarrayRef &) const { return false; }
   bool operator()(const semantics::ParamValue &param) const {
     return param.isExplicit() && (*this)(param.GetExplicit());
   }
   template <typename T> bool operator()(const FunctionRef<T> &call) const {
     if (const auto *intrinsic{std::get_if<SpecificIntrinsic>(&call.proc().u)}) {
       return intrinsic->name == "kind";

 
 // Specification expression validation (10.1.11(2), C1010)
 class CheckSpecificationExprHelper
     : public AnyTraverse<CheckSpecificationExprHelper,
           std::optional<std::string>> {
 public:
   using Result = std::optional<std::string>;
   using Base = AnyTraverse<CheckSpecificationExprHelper, Result>;
-  explicit CheckSpecificationExprHelper(const semantics::Scope &s)
-      : Base{*this}, scope_{s} {}
+  explicit CheckSpecificationExprHelper(
+      const semantics::Scope &s, const IntrinsicProcTable &table)
+      : Base{*this}, scope_{s}, table_{table} {}
   using Base::operator();
 
   Result operator()(const ProcedureDesignator &) const {
     return "dummy procedure argument";
   }
   Result operator()(const CoarrayRef &) const { return "coindexed reference"; }
 
   Result operator()(const semantics::Symbol &symbol) const {
     if (semantics::IsNamedConstant(symbol)) {
       return std::nullopt;
+    } else if (scope_.IsDerivedType() && IsVariableName(symbol)) { // C750
+      return "reference to variable '"s + symbol.name().ToString() +
+          "' not allowed for derived type components";
     } else if (symbol.IsDummy()) {
       if (symbol.attrs().test(semantics::Attr::OPTIONAL)) {
         return "reference to OPTIONAL dummy argument '"s +
             symbol.name().ToString() + "'";
       } else if (symbol.attrs().test(semantics::Attr::INTENT_OUT)) {
         return "reference to INTENT(OUT) dummy argument '"s +
             symbol.name().ToString() + "'";
       } else if (symbol.has<semantics::ObjectEntityDetails>()) {
public:
   }
   Result operator()(const DescriptorInquiry &) const {
     // Subtle: Uses of SIZE(), LBOUND(), &c. that are valid in specification
     // expressions will have been converted to expressions over descriptor
     // inquiries by Fold().
     return std::nullopt;
   }
 
+  template <int KIND>
+  Result operator()(const TypeParamInquiry<KIND> &inq) const {
+    if (scope_.IsDerivedType() && !IsConstantExpr(inq)) { // C750
+      return "non-constant reference to a type parameter inquiry "
+             "not allowed for derived type components";
+    }
+    return std::nullopt;
+  }
+
   template <typename T> Result operator()(const FunctionRef<T> &x) const {
     if (const auto *symbol{x.proc().GetSymbol()}) {
       if (!semantics::IsPureProcedure(*symbol)) {
         return "reference to impure function '"s + symbol->name().ToString() +
             "'";
       }
+      if (semantics::IsStmtFunction(*symbol)) {
+        return "reference to statement function '"s +
+            symbol->name().ToString() + "'";
+      }
+      if (scope_.IsDerivedType()) { // C750
+        return "reference to function '"s + symbol->name().ToString() +
+            "' not allowed for derived type components";
+      }
       // TODO: other checks for standard module procedures
     } else {
       const SpecificIntrinsic &intrin{DEREF(x.proc().GetSpecificIntrinsic())};
-      if (intrin.name == "present") {
+      if (scope_.IsDerivedType()) { // C750
+        if ((table_.IsIntrinsic(intrin.name) &&
+                badIntrinsicsForComponents_.find(intrin.name) !=
+                    badIntrinsicsForComponents_.end()) ||
+            IsProhibitedFunction(intrin.name)) {
+          return "reference to intrinsic '"s + intrin.name +
+              "' not allowed for derived type components";
+        }
+        if (table_.GetIntrinsicClass(intrin.name) ==
+                IntrinsicClass::inquiryFunction &&
+            !IsConstantExpr(x)) {
+          return "non-constant reference to inquiry intrinsic '"s +
+              intrin.name + "' not allowed for derived type components";
+        }
+      } else if (intrin.name == "present") {
         return std::nullopt; // no need to check argument(s)
       }
       if (IsConstantExpr(x)) {
         // inquiry functions may not need to check argument(s)
         return std::nullopt;
       }
     }
     return (*this)(x.arguments());
   }
 
 private:
   const semantics::Scope &scope_;
+  const IntrinsicProcTable &table_;
+  const std::set<std::string> badIntrinsicsForComponents_{
+      "allocated", "associated", "extends_type_of", "present", "same_type_as"};
+  static bool IsProhibitedFunction(std::string name) { return false; }
 };
 
 template <typename A>
 void CheckSpecificationExpr(const A &x, parser::ContextualMessages &messages,
-    const semantics::Scope &scope) {
-  if (auto why{CheckSpecificationExprHelper{scope}(x)}) {
+    const semantics::Scope &scope, const IntrinsicProcTable &table) {
+  if (auto why{CheckSpecificationExprHelper{scope, table}(x)}) {
     messages.Say("Invalid specification expression: %s"_err_en_US, *why);
   }
 }
 
 template void CheckSpecificationExpr(const Expr<SomeType> &,
-    parser::ContextualMessages &, const semantics::Scope &);
+    parser::ContextualMessages &, const semantics::Scope &,
+    const IntrinsicProcTable &);
 template void CheckSpecificationExpr(const Expr<SomeInteger> &,
-    parser::ContextualMessages &, const semantics::Scope &);
+    parser::ContextualMessages &, const semantics::Scope &,
+    const IntrinsicProcTable &);
 template void CheckSpecificationExpr(const Expr<SubscriptInteger> &,
-    parser::ContextualMessages &, const semantics::Scope &);
+    parser::ContextualMessages &, const semantics::Scope &,
+    const IntrinsicProcTable &);
 template void CheckSpecificationExpr(const std::optional<Expr<SomeType>> &,
-    parser::ContextualMessages &, const semantics::Scope &);
+    parser::ContextualMessages &, const semantics::Scope &,
+    const IntrinsicProcTable &);
 template void CheckSpecificationExpr(const std::optional<Expr<SomeInteger>> &,
-    parser::ContextualMessages &, const semantics::Scope &);
+    parser::ContextualMessages &, const semantics::Scope &,
+    const IntrinsicProcTable &);
 template void CheckSpecificationExpr(
     const std::optional<Expr<SubscriptInteger>> &, parser::ContextualMessages &,
-    const semantics::Scope &);
+    const semantics::Scope &, const IntrinsicProcTable &);
 
 // 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)

flang/lib/Evaluate/intrinsics.cpp

static constexpr IntrinsicDummyArgument OptionalMASK{
     "mask", AnyLogical, Rank::conformable, Optionality::optional};
 
 struct IntrinsicInterface {
   static constexpr int maxArguments{7}; // if not a MAX/MIN(...)
   const char *name{nullptr};
   IntrinsicDummyArgument dummy[maxArguments];
   TypePattern result;
   Rank rank{Rank::elemental};
+  IntrinsicClass intrinsicClass{IntrinsicClass::elementalFunction};
   std::optional<SpecificCall> Match(const CallCharacteristics &,
       const common::IntrinsicTypeDefaultKinds &, ActualArguments &,
       FoldingContext &context) const;
   int CountArguments() const;
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 };
 
 int IntrinsicInterface::CountArguments() const {
static const IntrinsicInterface genericIntrinsicFunction[]{
     {"acos", {{"x", SameFloating}}, SameFloating},
     {"acosd", {{"x", SameFloating}}, SameFloating},
     {"acosh", {{"x", SameFloating}}, SameFloating},
     {"adjustl", {{"string", SameChar}}, SameChar},
     {"adjustr", {{"string", SameChar}}, SameChar},
     {"aimag", {{"x", SameComplex}}, SameReal},
     {"aint", {{"a", SameReal}, MatchingDefaultKIND}, KINDReal},
     {"all", {{"mask", SameLogical, Rank::array}, OptionalDIM}, SameLogical,
-        Rank::dimReduced},
-    {"allocated", {{"array", AnyData, Rank::array}}, DefaultLogical},
-    {"allocated", {{"scalar", AnyData, Rank::scalar}}, DefaultLogical},
+        Rank::dimReduced, IntrinsicClass::transformationalFunction},
+    {"allocated", {{"array", AnyData, Rank::array}}, DefaultLogical,
+        Rank::elemental, IntrinsicClass::inquiryFunction},
+    {"allocated", {{"scalar", AnyData, Rank::scalar}}, DefaultLogical,
+        Rank::elemental, IntrinsicClass::inquiryFunction},
     {"anint", {{"a", SameReal}, MatchingDefaultKIND}, KINDReal},
     {"any", {{"mask", SameLogical, Rank::array}, OptionalDIM}, SameLogical,
-        Rank::dimReduced},
+        Rank::dimReduced, IntrinsicClass::transformationalFunction},
     {"asin", {{"x", SameFloating}}, SameFloating},
     {"asind", {{"x", SameFloating}}, SameFloating},
     {"asinh", {{"x", SameFloating}}, SameFloating},
     {"associated",
         {{"pointer", Addressable, Rank::known},
             {"target", Addressable, Rank::known, Optionality::optional}},
-        DefaultLogical},
+        DefaultLogical, Rank::elemental, IntrinsicClass::inquiryFunction},
     {"atan", {{"x", SameFloating}}, SameFloating},
     {"atand", {{"x", SameFloating}}, SameFloating},
     {"atan", {{"y", OperandReal}, {"x", OperandReal}}, OperandReal},
     {"atand", {{"y", OperandReal}, {"x", OperandReal}}, OperandReal},
     {"atan2", {{"y", OperandReal}, {"x", OperandReal}}, OperandReal},
     {"atan2d", {{"y", OperandReal}, {"x", OperandReal}}, OperandReal},
     {"atanh", {{"x", SameFloating}}, SameFloating},
     {"bessel_j0", {{"x", SameReal}}, SameReal},
     {"bessel_j1", {{"x", SameReal}}, SameReal},
     {"bessel_jn", {{"n", AnyInt}, {"x", SameReal}}, SameReal},
     {"bessel_jn",
         {{"n1", AnyInt, Rank::scalar}, {"n2", AnyInt, Rank::scalar},
             {"x", SameReal, Rank::scalar}},
-        SameReal, Rank::vector},
+        SameReal, Rank::vector, IntrinsicClass::transformationalFunction},
     {"bessel_y0", {{"x", SameReal}}, SameReal},
     {"bessel_y1", {{"x", SameReal}}, SameReal},
     {"bessel_yn", {{"n", AnyInt}, {"x", SameReal}}, SameReal},
     {"bessel_yn",
         {{"n1", AnyInt, Rank::scalar}, {"n2", AnyInt, Rank::scalar},
             {"x", SameReal, Rank::scalar}},
-        SameReal, Rank::vector},
+        SameReal, Rank::vector, IntrinsicClass::transformationalFunction},
     {"bge",
         {{"i", AnyInt, Rank::elementalOrBOZ},
             {"j", AnyInt, Rank::elementalOrBOZ}},
         DefaultLogical},
     {"bgt",
         {{"i", AnyInt, Rank::elementalOrBOZ},
             {"j", AnyInt, Rank::elementalOrBOZ}},
         DefaultLogical},
     {"bit_size", {{"i", SameInt, Rank::anyOrAssumedRank}}, SameInt,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
     {"ble",
         {{"i", AnyInt, Rank::elementalOrBOZ},
             {"j", AnyInt, Rank::elementalOrBOZ}},
         DefaultLogical},
     {"blt",
         {{"i", AnyInt, Rank::elementalOrBOZ},
             {"j", AnyInt, Rank::elementalOrBOZ}},
         DefaultLogical},
     {"btest", {{"i", AnyInt, Rank::elementalOrBOZ}, {"pos", AnyInt}},
         DefaultLogical},
     {"ceiling", {{"a", AnyReal}, DefaultingKIND}, KINDInt},
     {"char", {{"i", AnyInt, Rank::elementalOrBOZ}, DefaultingKIND}, KINDChar},
     {"cmplx", {{"x", AnyComplex}, DefaultingKIND}, KINDComplex},
     {"cmplx",
         {{"x", AnyIntOrReal, Rank::elementalOrBOZ},
             {"y", AnyIntOrReal, Rank::elementalOrBOZ, Optionality::optional},
             DefaultingKIND},
         KINDComplex},
-    {"command_argument_count", {}, DefaultInt, Rank::scalar},
+    {"command_argument_count", {}, DefaultInt, Rank::scalar,
+        IntrinsicClass::transformationalFunction},
     {"conjg", {{"z", SameComplex}}, SameComplex},
     {"cos", {{"x", SameFloating}}, SameFloating},
     {"cosd", {{"x", SameFloating}}, SameFloating},
     {"cosh", {{"x", SameFloating}}, SameFloating},
     {"count", {{"mask", AnyLogical, Rank::array}, OptionalDIM, DefaultingKIND},
-        KINDInt, Rank::dimReduced},
+        KINDInt, Rank::dimReduced, IntrinsicClass::transformationalFunction},
     {"cshift",
         {{"array", SameType, Rank::array}, {"shift", AnyInt, Rank::dimRemoved},
             OptionalDIM},
-        SameType, Rank::conformable},
+        SameType, Rank::conformable, IntrinsicClass::transformationalFunction},
     {"dble", {{"a", AnyNumeric, Rank::elementalOrBOZ}}, DoublePrecision},
     {"digits", {{"x", AnyIntOrReal, Rank::anyOrAssumedRank}}, DefaultInt,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
     {"dim", {{"x", OperandIntOrReal}, {"y", OperandIntOrReal}},
         OperandIntOrReal},
     {"dot_product",
         {{"vector_a", AnyLogical, Rank::vector},
             {"vector_b", AnyLogical, Rank::vector}},
-        ResultLogical, Rank::scalar},
+        ResultLogical, Rank::scalar, IntrinsicClass::transformationalFunction},
     {"dot_product",
         {{"vector_a", AnyComplex, Rank::vector},
             {"vector_b", AnyNumeric, Rank::vector}},
-        ResultNumeric, Rank::scalar}, // conjugates vector_a
+        ResultNumeric, Rank::scalar, // conjugates vector_a
+        IntrinsicClass::transformationalFunction},
     {"dot_product",
         {{"vector_a", AnyIntOrReal, Rank::vector},
             {"vector_b", AnyNumeric, Rank::vector}},
-        ResultNumeric, Rank::scalar},
+        ResultNumeric, Rank::scalar, IntrinsicClass::transformationalFunction},
     {"dprod", {{"x", DefaultReal}, {"y", DefaultReal}}, DoublePrecision},
     {"dshiftl",
         {{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ},
             {"shift", AnyInt}},
         SameInt},
     {"dshiftl", {{"i", BOZ}, {"j", SameInt}, {"shift", AnyInt}}, SameInt},
     {"dshiftr",
         {{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ},
             {"shift", AnyInt}},
         SameInt},
     {"dshiftr", {{"i", BOZ}, {"j", SameInt}, {"shift", AnyInt}}, SameInt},
     {"eoshift",
         {{"array", SameIntrinsic, Rank::array},
             {"shift", AnyInt, Rank::dimRemoved},
             {"boundary", SameIntrinsic, Rank::dimRemoved,
                 Optionality::optional},
             OptionalDIM},
-        SameIntrinsic, Rank::conformable},
+        SameIntrinsic, Rank::conformable,
+        IntrinsicClass::transformationalFunction},
     {"eoshift",
         {{"array", SameDerivedType, Rank::array},
             {"shift", AnyInt, Rank::dimRemoved},
             {"boundary", SameDerivedType, Rank::dimRemoved}, OptionalDIM},
-        SameDerivedType, Rank::conformable},
+        SameDerivedType, Rank::conformable,
+        IntrinsicClass::transformationalFunction},
     {"epsilon", {{"x", SameReal, Rank::anyOrAssumedRank}}, SameReal,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
     {"erf", {{"x", SameReal}}, SameReal},
     {"erfc", {{"x", SameReal}}, SameReal},
     {"erfc_scaled", {{"x", SameReal}}, SameReal},
     {"exp", {{"x", SameFloating}}, SameFloating},
+    {"exp", {{"x", SameFloating}}, SameFloating},
     {"exponent", {{"x", AnyReal}}, DefaultInt},
+    {"exp", {{"x", SameFloating}}, SameFloating},
     {"extends_type_of",
         {{"a", ExtensibleDerived, Rank::anyOrAssumedRank},
             {"mold", ExtensibleDerived, Rank::anyOrAssumedRank}},
-        DefaultLogical, Rank::scalar},
+        DefaultLogical, Rank::scalar, IntrinsicClass::inquiryFunction},
     {"findloc",
         {{"array", AnyNumeric, Rank::array},
             {"value", AnyNumeric, Rank::scalar}, RequiredDIM, OptionalMASK,
             SizeDefaultKIND,
             {"back", AnyLogical, Rank::scalar, Optionality::optional}},
-        KINDInt, Rank::dimRemoved},
+        KINDInt, Rank::dimRemoved, IntrinsicClass::transformationalFunction},
     {"findloc",
         {{"array", AnyNumeric, Rank::array},
             {"value", AnyNumeric, Rank::scalar}, OptionalMASK, SizeDefaultKIND,
             {"back", AnyLogical, Rank::scalar, Optionality::optional}},
-        KINDInt, Rank::vector},
+        KINDInt, Rank::vector, IntrinsicClass::transformationalFunction},
     {"findloc",
         {{"array", SameChar, Rank::array}, {"value", SameChar, Rank::scalar},
             RequiredDIM, OptionalMASK, SizeDefaultKIND,
             {"back", AnyLogical, Rank::scalar, Optionality::optional}},
-        KINDInt, Rank::dimRemoved},
+        KINDInt, Rank::dimRemoved, IntrinsicClass::transformationalFunction},
     {"findloc",
         {{"array", SameChar, Rank::array}, {"value", SameChar, Rank::scalar},
             OptionalMASK, SizeDefaultKIND,
             {"back", AnyLogical, Rank::scalar, Optionality::optional}},
-        KINDInt, Rank::vector},
+        KINDInt, Rank::vector, IntrinsicClass::transformationalFunction},
     {"findloc",
         {{"array", AnyLogical, Rank::array},
             {"value", AnyLogical, Rank::scalar}, RequiredDIM, OptionalMASK,
             SizeDefaultKIND,
             {"back", AnyLogical, Rank::scalar, Optionality::optional}},
-        KINDInt, Rank::dimRemoved},
+        KINDInt, Rank::dimRemoved, IntrinsicClass::transformationalFunction},
     {"findloc",
         {{"array", AnyLogical, Rank::array},
             {"value", AnyLogical, Rank::scalar}, OptionalMASK, SizeDefaultKIND,
             {"back", AnyLogical, Rank::scalar, Optionality::optional}},
-        KINDInt, Rank::vector},
+        KINDInt, Rank::vector, IntrinsicClass::transformationalFunction},
     {"floor", {{"a", AnyReal}, DefaultingKIND}, KINDInt},
     {"fraction", {{"x", SameReal}}, SameReal},
     {"gamma", {{"x", SameReal}}, SameReal},
     {"huge", {{"x", SameIntOrReal, Rank::anyOrAssumedRank}}, SameIntOrReal,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
     {"hypot", {{"x", OperandReal}, {"y", OperandReal}}, OperandReal},
     {"iachar", {{"c", AnyChar}, DefaultingKIND}, KINDInt},
     {"iall", {{"array", SameInt, Rank::array}, OptionalDIM, OptionalMASK},
-        SameInt, Rank::dimReduced},
+        SameInt, Rank::dimReduced, IntrinsicClass::transformationalFunction},
     {"iany", {{"array", SameInt, Rank::array}, OptionalDIM, OptionalMASK},
-        SameInt, Rank::dimReduced},
+        SameInt, Rank::dimReduced, IntrinsicClass::transformationalFunction},
     {"iparity", {{"array", SameInt, Rank::array}, OptionalDIM, OptionalMASK},
-        SameInt, Rank::dimReduced},
+        SameInt, Rank::dimReduced, IntrinsicClass::transformationalFunction},
     {"iand", {{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ}}, SameInt},
     {"iand", {{"i", BOZ}, {"j", SameInt}}, SameInt},
     {"ibclr", {{"i", SameInt}, {"pos", AnyInt}}, SameInt},
     {"ibits", {{"i", SameInt}, {"pos", AnyInt}, {"len", AnyInt}}, SameInt},
     {"ibset", {{"i", SameInt}, {"pos", AnyInt}}, SameInt},
     {"ichar", {{"c", AnyChar}, DefaultingKIND}, KINDInt},
     {"ieor", {{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ}}, SameInt},
     {"ieor", {{"i", BOZ}, {"j", SameInt}}, SameInt},
static const IntrinsicInterface genericIntrinsicFunction[]{
     {"ior", {{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ}}, SameInt},
     {"ior", {{"i", BOZ}, {"j", SameInt}}, SameInt},
     {"ishft", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
     {"ishftc",
         {{"i", SameInt}, {"shift", AnyInt},
             {"size", AnyInt, Rank::elemental, Optionality::optional}},
         SameInt},
     {"is_contiguous", {{"array", Addressable, Rank::anyOrAssumedRank}},
-        DefaultLogical},
+        DefaultLogical, Rank::elemental, IntrinsicClass::inquiryFunction},
     {"is_iostat_end", {{"i", AnyInt}}, DefaultLogical},
     {"is_iostat_eor", {{"i", AnyInt}}, DefaultLogical},
-    {"kind", {{"x", AnyIntrinsic}}, DefaultInt},
+    {"kind", {{"x", AnyIntrinsic}}, DefaultInt, Rank::elemental,
+        IntrinsicClass::inquiryFunction},
     {"lbound",
         {{"array", AnyData, Rank::anyOrAssumedRank}, RequiredDIM,
             SizeDefaultKIND},
-        KINDInt, Rank::scalar},
+        KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
     {"lbound", {{"array", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
-        KINDInt, Rank::vector},
+        KINDInt, Rank::vector, IntrinsicClass::inquiryFunction},
     {"leadz", {{"i", AnyInt}}, DefaultInt},
     {"len", {{"string", AnyChar, Rank::anyOrAssumedRank}, DefaultingKIND},
-        KINDInt, Rank::scalar},
+        KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
     {"len_trim", {{"string", AnyChar}, DefaultingKIND}, KINDInt},
     {"lge", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
     {"lgt", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
     {"lle", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
     {"llt", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
     {"loc", {{"loc_argument", Addressable, Rank::anyOrAssumedRank}},
         SubscriptInt, Rank::scalar},
     {"log", {{"x", SameFloating}}, SameFloating},
     {"log10", {{"x", SameReal}}, SameReal},
     {"logical", {{"l", AnyLogical}, DefaultingKIND}, KINDLogical},
     {"log_gamma", {{"x", SameReal}}, SameReal},
     {"matmul",
         {{"array_a", AnyLogical, Rank::vector},
             {"array_b", AnyLogical, Rank::matrix}},
-        ResultLogical, Rank::vector},
+        ResultLogical, Rank::vector, IntrinsicClass::transformationalFunction},
     {"matmul",
         {{"array_a", AnyLogical, Rank::matrix},
             {"array_b", AnyLogical, Rank::vector}},
-        ResultLogical, Rank::vector},
+        ResultLogical, Rank::vector, IntrinsicClass::transformationalFunction},
     {"matmul",
         {{"array_a", AnyLogical, Rank::matrix},
             {"array_b", AnyLogical, Rank::matrix}},
-        ResultLogical, Rank::matrix},
+        ResultLogical, Rank::matrix, IntrinsicClass::transformationalFunction},
     {"matmul",
         {{"array_a", AnyNumeric, Rank::vector},
             {"array_b", AnyNumeric, Rank::matrix}},
-        ResultNumeric, Rank::vector},
+        ResultNumeric, Rank::vector, IntrinsicClass::transformationalFunction},
     {"matmul",
         {{"array_a", AnyNumeric, Rank::matrix},
             {"array_b", AnyNumeric, Rank::vector}},
-        ResultNumeric, Rank::vector},
+        ResultNumeric, Rank::vector, IntrinsicClass::transformationalFunction},
     {"matmul",
         {{"array_a", AnyNumeric, Rank::matrix},
             {"array_b", AnyNumeric, Rank::matrix}},
-        ResultNumeric, Rank::matrix},
+        ResultNumeric, Rank::matrix, IntrinsicClass::transformationalFunction},
     {"maskl", {{"i", AnyInt}, DefaultingKIND}, KINDInt},
     {"maskr", {{"i", AnyInt}, DefaultingKIND}, KINDInt},
     {"max",
         {{"a1", OperandIntOrReal}, {"a2", OperandIntOrReal},
             {"a3", OperandIntOrReal, Rank::elemental, Optionality::repeats}},
         OperandIntOrReal},
     {"max",
         {{"a1", SameChar}, {"a2", SameChar},
             {"a3", SameChar, Rank::elemental, Optionality::repeats}},
         SameChar},
     {"maxexponent", {{"x", AnyReal, Rank::anyOrAssumedRank}}, DefaultInt,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
     {"maxloc",
         {{"array", AnyRelatable, Rank::array}, OptionalDIM, OptionalMASK,
             SizeDefaultKIND,
             {"back", AnyLogical, Rank::scalar, Optionality::optional}},
-        KINDInt, Rank::dimReduced},
+        KINDInt, Rank::dimReduced, IntrinsicClass::transformationalFunction},
     {"maxval",
         {{"array", SameRelatable, Rank::array}, OptionalDIM, OptionalMASK},
-        SameRelatable, Rank::dimReduced},
+        SameRelatable, Rank::dimReduced,
+        IntrinsicClass::transformationalFunction},
     {"merge",
         {{"tsource", SameType}, {"fsource", SameType}, {"mask", AnyLogical}},
         SameType},
     {"merge_bits",
         {{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ},
             {"mask", SameInt, Rank::elementalOrBOZ}},
         SameInt},
     {"merge_bits",
         {{"i", BOZ}, {"j", SameInt}, {"mask", SameInt, Rank::elementalOrBOZ}},
         SameInt},
     {"min",
         {{"a1", OperandIntOrReal}, {"a2", OperandIntOrReal},
             {"a3", OperandIntOrReal, Rank::elemental, Optionality::repeats}},
         OperandIntOrReal},
     {"min",
         {{"a1", SameChar}, {"a2", SameChar},
             {"a3", SameChar, Rank::elemental, Optionality::repeats}},
         SameChar},
     {"minexponent", {{"x", AnyReal, Rank::anyOrAssumedRank}}, DefaultInt,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
     {"minloc",
         {{"array", AnyRelatable, Rank::array}, OptionalDIM, OptionalMASK,
             SizeDefaultKIND,
             {"back", AnyLogical, Rank::scalar, Optionality::optional}},
-        KINDInt, Rank::dimReduced},
+        KINDInt, Rank::dimReduced, IntrinsicClass::transformationalFunction},
     {"minval",
         {{"array", SameRelatable, Rank::array}, OptionalDIM, OptionalMASK},
-        SameRelatable, Rank::dimReduced},
+        SameRelatable, Rank::dimReduced,
+        IntrinsicClass::transformationalFunction},
     {"mod", {{"a", OperandIntOrReal}, {"p", OperandIntOrReal}},
         OperandIntOrReal},
     {"modulo", {{"a", OperandIntOrReal}, {"p", OperandIntOrReal}},
         OperandIntOrReal},
     {"nearest", {{"x", SameReal}, {"s", AnyReal}}, SameReal},
     {"new_line", {{"x", SameChar, Rank::anyOrAssumedRank}}, SameChar,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
     {"nint", {{"a", AnyReal}, DefaultingKIND}, KINDInt},
     {"norm2", {{"x", SameReal, Rank::array}, OptionalDIM}, SameReal,
-        Rank::dimReduced},
+        Rank::dimReduced, IntrinsicClass::transformationalFunction},
     {"not", {{"i", SameInt}}, SameInt},
     // NULL() is a special case handled in Probe() below
     {"out_of_range",
         {{"x", AnyIntOrReal}, {"mold", AnyIntOrReal, Rank::scalar}},
         DefaultLogical},
     {"out_of_range",
         {{"x", AnyReal}, {"mold", AnyInt, Rank::scalar},
             {"round", AnyLogical, Rank::scalar, Optionality::optional}},
         DefaultLogical},
     {"out_of_range", {{"x", AnyReal}, {"mold", AnyReal}}, DefaultLogical},
     {"pack",
         {{"array", SameType, Rank::array},
             {"mask", AnyLogical, Rank::conformable},
             {"vector", SameType, Rank::vector, Optionality::optional}},
-        SameType, Rank::vector},
+        SameType, Rank::vector, IntrinsicClass::transformationalFunction},
     {"parity", {{"mask", SameLogical, Rank::array}, OptionalDIM}, SameLogical,
-        Rank::dimReduced},
+        Rank::dimReduced, IntrinsicClass::transformationalFunction},
     {"popcnt", {{"i", AnyInt}}, DefaultInt},
     {"poppar", {{"i", AnyInt}}, DefaultInt},
     {"product",
         {{"array", SameNumeric, Rank::array}, OptionalDIM, OptionalMASK},
-        SameNumeric, Rank::dimReduced},
+        SameNumeric, Rank::dimReduced,
+        IntrinsicClass::transformationalFunction},
     {"precision", {{"x", AnyFloating, Rank::anyOrAssumedRank}}, DefaultInt,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
     {"present", {{"a", Addressable, Rank::anyOrAssumedRank}}, DefaultLogical,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
     {"radix", {{"x", AnyIntOrReal, Rank::anyOrAssumedRank}}, DefaultInt,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
     {"range", {{"x", AnyNumeric, Rank::anyOrAssumedRank}}, DefaultInt,
-        Rank::scalar},
-    {"rank", {{"a", AnyData, Rank::anyOrAssumedRank}}, DefaultInt,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::inquiryFunction},
+    {"rank", {{"a", AnyData, Rank::anyOrAssumedRank}}, DefaultInt, Rank::scalar,
+        IntrinsicClass::inquiryFunction},
     {"real", {{"a", SameComplex, Rank::elemental}},
         SameReal}, // 16.9.160(4)(ii)
     {"real", {{"a", AnyNumeric, Rank::elementalOrBOZ}, DefaultingKIND},
         KINDReal},
     {"reduce",
         {{"array", SameType, Rank::array},
             {"operation", SameType, Rank::reduceOperation}, OptionalDIM,
             OptionalMASK, {"identity", SameType, Rank::scalar},
             {"ordered", AnyLogical, Rank::scalar, Optionality::optional}},
-        SameType, Rank::dimReduced},
+        SameType, Rank::dimReduced, IntrinsicClass::transformationalFunction},
     {"repeat", {{"string", SameChar, Rank::scalar}, {"ncopies", AnyInt}},
-        SameChar, Rank::scalar},
+        SameChar, Rank::scalar, IntrinsicClass::transformationalFunction},
     {"reshape",
         {{"source", SameType, Rank::array}, {"shape", AnyInt, Rank::shape},
             {"pad", SameType, Rank::array, Optionality::optional},
             {"order", AnyInt, Rank::vector, Optionality::optional}},
-        SameType, Rank::shaped},
+        SameType, Rank::shaped, IntrinsicClass::transformationalFunction},
     {"rrspacing", {{"x", SameReal}}, SameReal},
     {"same_type_as",
         {{"a", ExtensibleDerived, Rank::anyOrAssumedRank},
             {"b", ExtensibleDerived, Rank::anyOrAssumedRank}},
-        DefaultLogical, Rank::scalar},
+        DefaultLogical, Rank::scalar, IntrinsicClass::inquiryFunction},
     {"scale", {{"x", SameReal}, {"i", AnyInt}}, SameReal},
     {"scan",
         {{"string", SameChar}, {"set", SameChar},
             {"back", AnyLogical, Rank::elemental, Optionality::optional},
             DefaultingKIND},
         KINDInt},
     {"selected_char_kind", {{"name", DefaultChar, Rank::scalar}}, DefaultInt,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::transformationalFunction},
     {"selected_int_kind", {{"r", AnyInt, Rank::scalar}}, DefaultInt,
-        Rank::scalar},
+        Rank::scalar, IntrinsicClass::transformationalFunction},
     {"selected_real_kind",
         {{"p", AnyInt, Rank::scalar},
             {"r", AnyInt, Rank::scalar, Optionality::optional},
             {"radix", AnyInt, Rank::scalar, Optionality::optional}},
-        DefaultInt, Rank::scalar},
+        DefaultInt, Rank::scalar, IntrinsicClass::transformationalFunction},
     {"selected_real_kind",
         {{"p", AnyInt, Rank::scalar, Optionality::optional},
             {"r", AnyInt, Rank::scalar},
             {"radix", AnyInt, Rank::scalar, Optionality::optional}},
-        DefaultInt, Rank::scalar},
+        DefaultInt, Rank::scalar, IntrinsicClass::transformationalFunction},
     {"selected_real_kind",
         {{"p", AnyInt, Rank::scalar, Optionality::optional},
             {"r", AnyInt, Rank::scalar, Optionality::optional},
             {"radix", AnyInt, Rank::scalar}},
-        DefaultInt, Rank::scalar},
+        DefaultInt, Rank::scalar, IntrinsicClass::transformationalFunction},
     {"set_exponent", {{"x", SameReal}, {"i", AnyInt}}, SameReal},
     {"shape", {{"source", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
-        KINDInt, Rank::vector},
+        KINDInt, Rank::vector, IntrinsicClass::inquiryFunction},
     {"shifta", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
     {"shiftl", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
     {"shiftr", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
     {"sign", {{"a", SameIntOrReal}, {"b", SameIntOrReal}}, SameIntOrReal},
     {"sin", {{"x", SameFloating}}, SameFloating},
     {"sind", {{"x", SameFloating}}, SameFloating},
     {"sinh", {{"x", SameFloating}}, SameFloating},
     {"size",
         {{"array", AnyData, Rank::anyOrAssumedRank}, OptionalDIM,
             SizeDefaultKIND},
-        KINDInt, Rank::scalar},
+        KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
     {"spacing", {{"x", SameReal}}, SameReal},
     {"spread",
         {{"source", SameType, Rank::known}, RequiredDIM,
             {"ncopies", AnyInt, Rank::scalar}},
-        SameType, Rank::rankPlus1},
+        SameType, Rank::rankPlus1, IntrinsicClass::transformationalFunction},
     {"sqrt", {{"x", SameFloating}}, SameFloating},
     {"storage_size", {{"a", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
-        KINDInt, Rank::scalar},
+        KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
     {"sum", {{"array", SameNumeric, Rank::array}, OptionalDIM, OptionalMASK},
-        SameNumeric, Rank::dimReduced},
+        SameNumeric, Rank::dimReduced,
+        IntrinsicClass::transformationalFunction},
     {"tan", {{"x", SameFloating}}, SameFloating},
     {"tand", {{"x", SameFloating}}, SameFloating},
     {"tanh", {{"x", SameFloating}}, SameFloating},
-    {"tiny", {{"x", SameReal, Rank::anyOrAssumedRank}}, SameReal, Rank::scalar},
+    {"tiny", {{"x", SameReal, Rank::anyOrAssumedRank}}, SameReal, Rank::scalar,
+        IntrinsicClass::inquiryFunction},
     {"trailz", {{"i", AnyInt}}, DefaultInt},
     {"transfer",
         {{"source", AnyData, Rank::known}, {"mold", SameType, Rank::scalar}},
-        SameType, Rank::scalar},
+        SameType, Rank::scalar, IntrinsicClass::transformationalFunction},
     {"transfer",
         {{"source", AnyData, Rank::known}, {"mold", SameType, Rank::array}},
-        SameType, Rank::vector},
+        SameType, Rank::vector, IntrinsicClass::transformationalFunction},
     {"transfer",
         {{"source", AnyData, Rank::anyOrAssumedRank},
             {"mold", SameType, Rank::anyOrAssumedRank},
             {"size", AnyInt, Rank::scalar}},
-        SameType, Rank::vector},
-    {"transpose", {{"matrix", SameType, Rank::matrix}}, SameType, Rank::matrix},
-    {"trim", {{"string", SameChar, Rank::scalar}}, SameChar, Rank::scalar},
+        SameType, Rank::vector, IntrinsicClass::transformationalFunction},
+    {"transpose", {{"matrix", SameType, Rank::matrix}}, SameType, Rank::matrix,
+        IntrinsicClass::transformationalFunction},
+    {"trim", {{"string", SameChar, Rank::scalar}}, SameChar, Rank::scalar,
+        IntrinsicClass::transformationalFunction},
     {"ubound",
         {{"array", AnyData, Rank::anyOrAssumedRank}, RequiredDIM,
             SizeDefaultKIND},
-        KINDInt, Rank::scalar},
+        KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
     {"ubound", {{"array", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
-        KINDInt, Rank::vector},
+        KINDInt, Rank::vector, IntrinsicClass::inquiryFunction},
     {"unpack",
         {{"vector", SameType, Rank::vector}, {"mask", AnyLogical, Rank::array},
             {"field", SameType, Rank::conformable}},
-        SameType, Rank::conformable},
+        SameType, Rank::conformable, IntrinsicClass::transformationalFunction},
     {"verify",
         {{"string", SameChar}, {"set", SameChar},
             {"back", AnyLogical, Rank::elemental, Optionality::optional},
             DefaultingKIND},
         KINDInt},
 };
 
 // TODO: Coarray intrinsic functions
static const SpecificIntrinsicInterface specificIntrinsicFunction[]{
     {{"sinh", {{"x", DefaultReal}}, DefaultReal}},
     {{"sngl", {{"a", AnyReal}}, DefaultReal}, "real", true},
     {{"sqrt", {{"x", DefaultReal}}, DefaultReal}},
     {{"tan", {{"x", DefaultReal}}, DefaultReal}},
     {{"tanh", {{"x", DefaultReal}}, DefaultReal}},
 };
 
 static const IntrinsicInterface intrinsicSubroutine[]{
-    {"cpu_time", {{"time", AnyReal, Rank::scalar}}, {}},
+    {"cpu_time", {{"time", AnyReal, Rank::scalar}}, {}, Rank::elemental,
+        IntrinsicClass::impureSubroutine},
     {"date_and_time",
         {{"date", DefaultChar, Rank::scalar, Optionality::optional},
             {"time", DefaultChar, Rank::scalar, Optionality::optional},
             {"zone", DefaultChar, Rank::scalar, Optionality::optional},
             {"values", AnyInt, Rank::vector, Optionality::optional}},
-        {}},
+        {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"execute_command_line",
         {{"command", DefaultChar, Rank::scalar},
             {"wait", AnyLogical, Rank::scalar, Optionality::optional},
             {"exitstat", AnyInt, Rank::scalar, Optionality::optional},
             {"cmdstat", AnyInt, Rank::scalar, Optionality::optional},
             {"cmdmsg", DefaultChar, Rank::scalar, Optionality::optional}},
-        {}},
+        {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"get_command",
         {{"command", DefaultChar, Rank::scalar, Optionality::optional},
             {"length", AnyInt, Rank::scalar, Optionality::optional},
             {"status", AnyInt, Rank::scalar, Optionality::optional},
             {"errmsg", DefaultChar, Rank::scalar, Optionality::optional}},
-        {}},
+        {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"get_command_argument",
         {{"number", AnyInt, Rank::scalar},
             {"value", DefaultChar, Rank::scalar, Optionality::optional},
             {"length", AnyInt, Rank::scalar, Optionality::optional},
             {"status", AnyInt, Rank::scalar, Optionality::optional},
             {"errmsg", DefaultChar, Rank::scalar, Optionality::optional}},
-        {}},
+        {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"get_environment_variable",
         {{"name", DefaultChar, Rank::scalar},
             {"value", DefaultChar, Rank::scalar, Optionality::optional},
             {"length", AnyInt, Rank::scalar, Optionality::optional},
             {"status", AnyInt, Rank::scalar, Optionality::optional},
             {"trim_name", AnyLogical, Rank::scalar, Optionality::optional},
             {"errmsg", DefaultChar, Rank::scalar, Optionality::optional}},
-        {}},
+        {}, Rank::elemental, IntrinsicClass::impureSubroutine},
     {"move_alloc",
         {{"from", SameType, Rank::known}, {"to", SameType, Rank::known},
             {"stat", AnyInt, Rank::scalar, Optionality::optional},
             {"errmsg", DefaultChar, Rank::scalar, Optionality::optional}},
-        {}},
+        {}, Rank::elemental, IntrinsicClass::pureSubroutine},
     {"mvbits",
         {{"from", SameInt}, {"frompos", AnyInt}, {"len", AnyInt},
             {"to", SameInt}, {"topos", AnyInt}},
-        {}}, // elemental
+        {}, Rank::elemental, IntrinsicClass::elementalSubroutine}, // elemental
     {"random_init",
         {{"repeatable", AnyLogical, Rank::scalar},
             {"image_distinct", AnyLogical, Rank::scalar}},
-        {}},
-    {"random_number", {{"harvest", AnyReal, Rank::known}}, {}},
+        {}, Rank::elemental, IntrinsicClass::impureSubroutine},
+    {"random_number", {{"harvest", AnyReal, Rank::known}}, {}, Rank::elemental,
+        IntrinsicClass::impureSubroutine},
     {"random_seed",
         {{"size", DefaultInt, Rank::scalar, Optionality::optional},
             {"put", DefaultInt, Rank::vector, Optionality::optional},
             {"get", DefaultInt, Rank::vector, Optionality::optional}},
-        {}}, // TODO: at most one argument can be present
+        {}, Rank::elemental,
+        IntrinsicClass::impureSubroutine}, // TODO: at most one argument can be
+                                           // present
     {"system_clock",
         {{"count", AnyInt, Rank::scalar, Optionality::optional},
             {"count_rate", AnyIntOrReal, Rank::scalar, Optionality::optional},
             {"count_max", AnyInt, Rank::scalar, Optionality::optional}},
-        {}},
+        {}, Rank::elemental, IntrinsicClass::impureSubroutine},
 };
 
 // TODO: Intrinsic subroutine EVENT_QUERY
 // TODO: Atomic intrinsic subroutines: ATOMIC_ADD &al.
 // TODO: Collective intrinsic subroutines: CO_BROADCAST &al.
 
 // Intrinsic interface matching against the arguments of a particular
 // procedure reference.
explicit Implementation(const common::IntrinsicTypeDefaultKinds &dfts)
     }
     for (const IntrinsicInterface &f : intrinsicSubroutine) {
       subroutines_.insert(std::make_pair(std::string{f.name}, &f));
     }
   }
 
   bool IsIntrinsic(const std::string &) const;
 
+  IntrinsicClass GetIntrinsicClass(const std::string &) const;
+
   std::optional<SpecificCall> Probe(const CallCharacteristics &,
       ActualArguments &, FoldingContext &, const IntrinsicProcTable &) const;
 
   std::optional<SpecificIntrinsicFunctionInterface> IsSpecificIntrinsicFunction(
       const std::string &) const;
 
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
bool IntrinsicProcTable::Implementation::IsIntrinsic(
   auto subrRange{subroutines_.equal_range(name)};
   if (subrRange.first != subrRange.second) {
     return true;
   }
   // special cases
   return name == "null" || name == "__builtin_c_f_pointer";
 }
 
+IntrinsicClass IntrinsicProcTable::Implementation::GetIntrinsicClass(
+    const std::string &name) const {
+  auto specificIntrinsic{specificFuncs_.find(name)};
+  if (specificIntrinsic != specificFuncs_.end()) {
+    return specificIntrinsic->second->intrinsicClass;
+  }
+  auto genericIntrinsic{genericFuncs_.find(name)};
+  if (genericIntrinsic != genericFuncs_.end()) {
+    return genericIntrinsic->second->intrinsicClass;
+  }
+  auto subrIntrinsic{subroutines_.find(name)};
+  if (subrIntrinsic != subroutines_.end()) {
+    return subrIntrinsic->second->intrinsicClass;
+  }
+  return IntrinsicClass::noClass;
+}
+
 bool CheckAndRearrangeArguments(ActualArguments &arguments,
     parser::ContextualMessages &messages, const char *const dummyKeywords[],
     std::size_t trailingOptionals) {
   std::size_t numDummies{0};
   while (dummyKeywords[numDummies]) {
     ++numDummies;
   }
   CHECK(trailingOptionals <= numDummies);
IntrinsicProcTable IntrinsicProcTable::Configure(
   result.impl_ = new IntrinsicProcTable::Implementation(defaults);
   return result;
 }
 
 bool IntrinsicProcTable::IsIntrinsic(const std::string &name) const {
   return DEREF(impl_).IsIntrinsic(name);
 }
 
+IntrinsicClass IntrinsicProcTable::GetIntrinsicClass(
+    const std::string &name) const {
+  return DEREF(impl_).GetIntrinsicClass(name);
+}
+
 std::optional<SpecificCall> IntrinsicProcTable::Probe(
     const CallCharacteristics &call, ActualArguments &arguments,
     FoldingContext &context) const {
   return DEREF(impl_).Probe(call, arguments, context, *this);
 }
 
 std::optional<SpecificIntrinsicFunctionInterface>
 IntrinsicProcTable::IsSpecificIntrinsicFunction(const std::string &name) const {

flang/lib/Semantics/check-declarations.cpp

private:
   template <typename A> void CheckSpecExpr(const A &x) {
     if (symbolBeingChecked_ && IsSaved(*symbolBeingChecked_)) {
       if (!evaluate::IsConstantExpr(x)) {
         messages_.Say(
             "Specification expression must be constant in declaration of '%s' with the SAVE attribute"_err_en_US,
             symbolBeingChecked_->name());
       }
     } else {
-      evaluate::CheckSpecificationExpr(x, messages_, DEREF(scope_));
+      evaluate::CheckSpecificationExpr(
+          x, messages_, DEREF(scope_), context_.intrinsics());
     }
   }
   template <typename A> void CheckSpecExpr(const std::optional<A> &x) {
     if (x) {
       CheckSpecExpr(*x);
     }
   }
   template <typename A> void CheckSpecExpr(A &x) {
void CheckHelper::CheckObjectEntity(
   CHECK(!symbolBeingChecked_);
   symbolBeingChecked_ = &symbol; // for specification expr checks
   CheckArraySpec(symbol, details.shape());
   Check(details.shape());
   Check(details.coshape());
   CheckAssumedTypeEntity(symbol, details);
   symbolBeingChecked_ = nullptr;
   if (!details.coshape().empty()) {
+    bool isDeferredShape{details.coshape().IsDeferredShape()};
     if (IsAllocatable(symbol)) {
-      if (!details.coshape().IsDeferredShape()) { // C827
-        messages_.Say(
-            "ALLOCATABLE coarray must have a deferred coshape"_err_en_US);
+      if (!isDeferredShape) { // C827
+        messages_.Say("'%s' is an ALLOCATABLE coarray and must have a deferred"
+                      " coshape"_err_en_US,
+            symbol.name());
       }
+    } else if (symbol.owner().IsDerivedType()) { // C746
+      std::string deferredMsg{
+          isDeferredShape ? "" : " and have a deferred coshape"};
+      messages_.Say("Component '%s' is a coarray and must have the ALLOCATABLE"
+                    " attribute%s"_err_en_US,
+          symbol.name(), deferredMsg);
     } else {
       if (!details.coshape().IsAssumedSize()) { // C828
         messages_.Say(
-            "Non-ALLOCATABLE coarray must have an explicit coshape"_err_en_US);
+            "Component '%s' is a non-ALLOCATABLE coarray and must have"
+            " an explicit coshape"_err_en_US,
+            symbol.name());
       }
     }
   }
   if (details.isDummy()) {
     if (symbol.attrs().test(Attr::INTENT_OUT)) {
       if (FindUltimateComponent(symbol, [](const Symbol &x) {
             return IsCoarray(x) && IsAllocatable(x);
           })) { // C846
         messages_.Say(
             "An INTENT(OUT) dummy argument may not be, or contain, an ALLOCATABLE coarray"_err_en_US);
       }
       if (IsOrContainsEventOrLockComponent(symbol)) { // C847
         messages_.Say(
             "An INTENT(OUT) dummy argument may not be, or contain, EVENT_TYPE or LOCK_TYPE"_err_en_US);
       }
     }
-    if (InPure() && !IsPointer(symbol) && !IsIntentIn(symbol) &&
+    if (InPure() && !IsStmtFunction(DEREF(innermostSymbol_)) &&
+        !IsPointer(symbol) && !IsIntentIn(symbol) &&
         !symbol.attrs().test(Attr::VALUE)) {
       if (InFunction()) { // C1583
         messages_.Say(
             "non-POINTER dummy argument of pure function must be INTENT(IN) or VALUE"_err_en_US);
       } else if (IsIntentOut(symbol)) {
         if (const DeclTypeSpec * type{details.type()}) {
           if (type && type->IsPolymorphic()) { // C1588
             messages_.Say(

flang/lib/Semantics/expression.cpp

if (chars) {
     bool treatExternalAsImplicit{IsExternalCalledImplicitly(callSite, proc)};
     if (treatExternalAsImplicit && !chars->CanBeCalledViaImplicitInterface()) {
       Say(callSite,
           "References to the procedure '%s' require an explicit interface"_en_US,
           DEREF(proc.GetSymbol()).name());
     }
     semantics::CheckArguments(*chars, arguments, GetFoldingContext(),
         context_.FindScope(callSite), treatExternalAsImplicit);
-    if (!chars->attrs.test(characteristics::Procedure::Attr::Pure)) {
+    const Symbol *procSymbol{proc.GetSymbol()};
+    if (procSymbol && !IsPureProcedure(*procSymbol)) {
       if (const semantics::Scope *
           pure{semantics::FindPureProcedureContaining(
               context_.FindScope(callSite))}) {
         Say(callSite,
             "Procedure '%s' referenced in pure subprogram '%s' must be pure too"_err_en_US,
-            DEREF(proc.GetSymbol()).name(), DEREF(pure->symbol()).name());
+            procSymbol->name(), DEREF(pure->symbol()).name());
       }
     }
   }
   return chars;
 }
 
 // Unary operations
 

flang/lib/Semantics/resolve-names.cpp

if (!paramNames.insert(paramName.source).second) {
       Say(paramName,
           "Duplicate type parameter name: '%s'"_err_en_US); // C731
     }
   }
   for (const auto &[name, symbol] : currScope()) {
     if (symbol->has<TypeParamDetails>() && !paramNames.count(name)) {
       SayDerivedType(name,
           "'%s' is not a type parameter of this derived type"_err_en_US,
-          currScope()); // C742
+          currScope()); // C741
     }
   }
   Walk(std::get<std::list<parser::Statement<parser::PrivateOrSequence>>>(x.t));
   const auto &componentDefs{
       std::get<std::list<parser::Statement<parser::ComponentDefStmt>>>(x.t)};
   Walk(componentDefs);
   if (derivedTypeInfo_.sequence) {
     details.set_sequence(true);

 }
 void DeclarationVisitor::Post(const parser::ComponentDecl &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   auto attrs{GetAttrs()};
   if (derivedTypeInfo_.privateComps &&
       !attrs.HasAny({Attr::PUBLIC, Attr::PRIVATE})) {
     attrs.set(Attr::PRIVATE);
   }
-  if (!attrs.HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {
-    if (const auto *declType{GetDeclTypeSpec()}) {
-      if (const auto *derived{declType->AsDerived()}) {
+      if (!attrs.HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {
         if (derivedTypeInfo_.type == &derived->typeSymbol()) { // C744
           Say("Recursive use of the derived type requires "
               "POINTER or ALLOCATABLE"_err_en_US);
         }
       }
+      if (!coarraySpec().empty()) { // C747
+        if (IsTeamType(derived)) {
+          Say("A coarray component may not be of type TEAM_TYPE from "
+              "ISO_FORTRAN_ENV"_err_en_US);
+        } else {
+          if (IsIsoCType(derived)) {
+            Say("A coarray component may not be of type C_PTR or C_FUNPTR from "
+                "ISO_C_BINDING"_err_en_US);
+          }
+        }
+      }
+      if (auto it{FindCoarrayUltimateComponent(*derived)}) { // C748
+        std::string ultimateName{it.BuildResultDesignatorName()};
+        // Strip off the leading "%"
+        if (ultimateName.length() > 1) {
+          ultimateName.erase(0, 1);
+          if (attrs.HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {
+            evaluate::AttachDeclaration(
+                Say(name.source,
+                    "A component with a POINTER or ALLOCATABLE attribute may "
+                    "not "
+                    "be of a type with a coarray ultimate component (named "
+                    "'%s')"_err_en_US,
+                    ultimateName),
+                derived->typeSymbol());
+          }
+          if (!arraySpec().empty() || !coarraySpec().empty()) {
+            evaluate::AttachDeclaration(
+                Say(name.source,
+                    "An array or coarray component may not be of a type with a "
+                    "coarray ultimate component (named '%s')"_err_en_US,
+                    ultimateName),
+                derived->typeSymbol());
+          }
+        }
+      }
     }
   }
   if (OkToAddComponent(name)) {
     auto &symbol{DeclareObjectEntity(name, attrs)};
     if (symbol.has<ObjectEntityDetails>()) {
       if (auto &init{std::get<std::optional<parser::Initialization>>(x.t)}) {
         Initialization(name, *init, true);
       }

 Symbol *DeclarationVisitor::MakeTypeSymbol(
     const parser::Name &name, Details &&details) {
   return Resolve(name, MakeTypeSymbol(name.source, std::move(details)));
 }
 Symbol *DeclarationVisitor::MakeTypeSymbol(
     const SourceName &name, Details &&details) {
   Scope &derivedType{currScope()};
   CHECK(derivedType.IsDerivedType());
-  if (auto *symbol{FindInScope(derivedType, name)}) {
+  if (auto *symbol{FindInScope(derivedType, name)}) { // C742
     Say2(name,
         "Type parameter, component, or procedure binding '%s'"
         " already defined in this type"_err_en_US,
         *symbol, "Previous definition of '%s'"_en_US);
     return nullptr;
   } else {
     auto attrs{GetAttrs()};
     // Apply binding-private-stmt if present and this is a procedure binding

flang/lib/Semantics/tools.cpp

if (const Symbol * procInterface{procDetails->interface().symbol()}) {
       // procedure component with a pure interface
       return IsPureProcedure(*procInterface);
     }
   } else if (const auto *details{symbol.detailsIf<ProcBindingDetails>()}) {
     return IsPureProcedure(details->symbol());
   } else if (!IsProcedure(symbol)) {
     return false;
   }
+  if (IsStmtFunction(symbol)) {
+    // Section 15.7(1) states that a statement function is PURE if it does not
+    // reference an IMPURE procedure or a VOLATILE variable
+    const MaybeExpr &expr{symbol.get<SubprogramDetails>().stmtFunction()};
+    if (expr) {
+      for (const Symbol &refSymbol : evaluate::CollectSymbols(*expr)) {
+        if (IsFunction(refSymbol) && !IsPureProcedure(refSymbol)) {
+          return false;
+        }
+        if (const Symbol * root{GetAssociationRoot(refSymbol)}) {
+          if (root->attrs().test(Attr::VOLATILE)) {
+            return false;
+          }
+        }
+      }
+    }
+    return true; // statement function was not found to be impure
+  }
   return symbol.attrs().test(Attr::PURE) ||
       (symbol.attrs().test(Attr::ELEMENTAL) &&
           !symbol.attrs().test(Attr::IMPURE));
 }
 
 bool IsPureProcedure(const Scope &scope) {
   if (const Symbol * symbol{scope.GetSymbol()}) {
     return IsPureProcedure(*symbol);

 }
 
 void LabelEnforce::SayWithConstruct(SemanticsContext &context,
     parser::CharBlock stmtLocation, parser::MessageFormattedText &&message,
     parser::CharBlock constructLocation) {
   context.Say(stmtLocation, message)
       .Attach(constructLocation, GetEnclosingConstructMsg());
 }
+
 } // namespace Fortran::semantics

flang/test/Semantics/allocate11.f90

 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Check for semantic errors in ALLOCATE statements
 
 ! TODO: Function Pointer in allocate and derived types!
 
 ! Rules I should know when working with coarrays and derived type:
 
-! C736: If EXTENDS appears and the type being defined has a coarray ultimate
-! component, its parent type shall have a coarray ultimate component.
-
-! C746: (R737) If a coarray-spec appears, it shall be a deferred-coshape-spec-list
-! and the component shall have the ALLOCATABLE attribute.
-
-! C747: If a coarray-spec appears, the component shall not be of type C_PTR or
-! C_FUNPTR from the intrinsic module ISO_C_BINDING (18.2), or of type TEAM_TYPE from the
-! intrinsic module ISO_FORTRAN_ENV (16.10.2).
-
-! C748: A data component whose type has a coarray ultimate component shall be a
-! nonpointer nonallocatable scalar and shall not be a coarray.
-
 ! 7.5.4.3 Coarray components
 ! 7.5.6 Final subroutines: C786
 
 
 ! C825 An entity whose type has a coarray ultimate component shall be a
 ! nonpointer nonallocatable scalar, shall not be a coarray, and shall not be a function result.
 
 ! C826 A coarray or an object with a coarray ultimate component shall be an
 ! associate name, a dummy argument, or have the ALLOCATABLE or SAVE attribute.
 
 subroutine C937(var)
 ! Type-spec shall not specify a type that has a coarray ultimate component.
 
 
   type A
     real, allocatable :: x[:]
   end type
 
   type B
     type(A) y
-    type(B), pointer :: forward
     real :: u
   end type
 
   type C
     type(B) z
   end type
 
   type D
-    type(A), pointer :: potential
+    type(A) :: potential
   end type
 
 
 
   class(*), allocatable :: var
   ! unlimited polymorphic is the ONLY way to get an allocatable/pointer 'var' that can be
   ! allocated with a type-spec T that has coarray ultimate component without
   ! violating other rules than C937.
   ! Rationale:
   !   C934 => var must be type compatible with T.
   !        => var type is T, a type P extended by T, or unlimited polymorphic
   !   C825 => var cannot be of type T.
   !   C736 => all parent types P of T must have a coarray ultimate component
   !        => var cannot be of type P (C825)
   !        => if var can be defined, it can only be unlimited polymorphic
 
   ! Also, as per C826 or C852, var can only be an allocatable, not a pointer
 
-  ! OK, x is not an ultimate component
-  allocate(D:: var)
-
   !ERROR: Type-spec in ALLOCATE must not specify a type with a coarray ultimate component
   allocate(A:: var)
   !ERROR: Type-spec in ALLOCATE must not specify a type with a coarray ultimate component
   allocate(B:: var)
   !ERROR: Type-spec in ALLOCATE must not specify a type with a coarray ultimate component
   allocate(C:: var)
 end subroutine
 

flang/test/Semantics/assign04.f90

 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! 9.4.5
 subroutine s1
   type :: t(k, l)
     integer, kind :: k
     integer, len :: l
   end type
   type(t(1, 2)) :: x
-  !ERROR: Assignment to constant 'x%k' is not allowed
+  !ERROR: Left-hand side of assignment is not modifiable
   x%k = 4
   !ERROR: Left-hand side of assignment is not modifiable
   x%l = 3
 end
 
 ! C901
 subroutine s2(x)
   !ERROR: A dummy argument may not also be a named constant
subroutine s3
   end type
   type(t) :: x
   type(t), parameter :: y = t([1,2], 3)
   integer :: i = 1
   x%a(i) = 1
   !ERROR: Left-hand side of assignment is not modifiable
   y%a(i) = 2
   x%b = 4
-  !ERROR: Left-hand side of assignment is not modifiable
+  !ERROR: Assignment to constant 'y' is not allowed
   y%b = 5
 end
 
 ! C844
 subroutine s4
   type :: t
     integer :: a(2)
   end type

flang/test/Semantics/call10.f90

pure subroutine s09 ! C1593
     x = volatile
   end subroutine
   ! C1594 is tested in call12.f90.
   pure subroutine s10 ! C1595
     integer :: n
     !ERROR: Procedure 'notpure' referenced in pure subprogram 's10' must be pure too
     n = notpure(1)
   end subroutine
+  pure subroutine s10a
+    integer :: iVar
+    iStmtFunc(iArg) = iArg + 3
+    !OK, since a statement function is pure by default
+    iVar = iStmtFunc(4)
+  end subroutine
   pure subroutine s11(to) ! C1596
     ! Implicit deallocation at the end of the subroutine
     !ERROR: Deallocation of polymorphic object 'auto%a' is not permitted in a pure subprogram
     type(polyAlloc) :: auto
     type(polyAlloc), intent(in out) :: to
     !ERROR: Deallocation of polymorphic non-coarray component '%a' is not permitted in a pure subprogram
     to = auto
   end subroutine

flang/test/Semantics/call12.f90

type :: t
     sequence
     real :: a
   end type
   type(t), target :: x
   type :: hasPtr
     real, pointer :: p
   end type
   type :: hasCoarray
-    real :: co[*]
+    real, allocatable :: co[:]
   end type
  contains
   pure function test(ptr, in, hpd)
     use used
     type(t), pointer :: ptr, ptr2
     type(t), target, intent(in) :: in
     type(t), target :: y, z
     type(hasPtr) :: hp

flang/test/Semantics/call14.f90

 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Test 8.5.18 constraints on the VALUE attribute
 
 module m
   type :: hasCoarray
-    real :: coarray[*]
+    real, allocatable :: coarray[:]
   end type
  contains
   !ERROR: VALUE attribute may apply only to a dummy data object
   subroutine C863(notData,assumedSize,coarray,coarrayComponent)
     external :: notData
     !ERROR: VALUE attribute may apply only to a dummy argument
     real, value :: notADummy
     value :: notData

flang/test/Semantics/misc-declarations.f90

 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Miscellaneous constraint and requirement checking on declarations:
 ! - 8.5.6.2 & 8.5.6.3 constraints on coarrays
 ! - 8.5.19 constraints on the VOLATILE attribute
 
 module m
-  !ERROR: ALLOCATABLE coarray must have a deferred coshape
+  !ERROR: 'mustbedeferred' is an ALLOCATABLE coarray and must have a deferred coshape
   real, allocatable :: mustBeDeferred[*]  ! C827
-  !ERROR: Non-ALLOCATABLE coarray must have an explicit coshape
+  !ERROR: Component 'mustbeexplicit' is a non-ALLOCATABLE coarray and must have an explicit coshape
   real :: mustBeExplicit[:]  ! C828
   type :: hasCoarray
-    real :: coarray[*]
+    real, allocatable :: coarray[:]
   end type
   real :: coarray[*]
   type(hasCoarray) :: coarrayComponent
  contains
   !ERROR: VOLATILE attribute may not apply to an INTENT(IN) argument
   subroutine C866(x)
     intent(in) :: x
     volatile :: x

flang/test/Semantics/modfile24.f90

 ! real(4)::b[1_8:*]
 ! real(4),target::c[1_8:10_8,1_8:*]
 ! real(4),target::d[1_8:*]
 !end
 
 ! coarray-spec in components and with non-constants bounds
 module m3
   type t
-    real :: c[1:10,1:*]
-    complex, codimension[5,*] :: d
+    real, allocatable :: c[:,:]
+    complex, allocatable, codimension[:,:] :: d
   end type
   real, allocatable :: e[:,:,:]
 contains
   subroutine s(a, b, n)
     integer(8) :: n
     real :: a[1:n,2:*]
     real, codimension[1:n,2:*] :: b
   end
 end
 !Expect: m3.mod
 !module m3
 ! type::t
-!  real(4)::c[1_8:10_8,1_8:*]
-!  complex(4)::d[1_8:5_8,1_8:*]
+!  real(4),allocatable::c[:,:]
+!  complex(4),allocatable::d[:,:]
 ! end type
 ! real(4),allocatable::e[:,:,:]
 !contains
 ! subroutine s(a,b,n)
 !  integer(8)::n
 !  real(4)::a[1_8:n,2_8:*]
 !  real(4)::b[1_8:n,2_8:*]
 ! end

flang/test/Semantics/resolve33.f90

 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Derived type parameters
 ! C731 The same type-param-name shall not appear more than once in a given
 ! derived-type-stmt.
+! C741 A type-param-name in a type-param-def-stmt in a derived-type-def shall
+! be one of the type-paramnames in the derived-type-stmt of that
+! derived-type-def.
+! C742 Each type-param-name in the derived-type-stmt in a derived-type-def
+! shall appear exactly once as a type-param-name in a type-param-def-stmt 
+! in that derived-type-def.
 
 module m
   !ERROR: Duplicate type parameter name: 'a'
   type t1(a, b, a)
     integer, kind :: a
     integer(8), len :: b
   end type
   !ERROR: No definition found for type parameter 'b'

flang/test/Semantics/resolve44.f90

 ! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
 ! Error tests for recursive use of derived types.
+! C744 If neither the POINTER nor the ALLOCATABLE attribute is specified, the
+! declaration-type-spec in the component-def-stmt shall specify an intrinsic
+! type or a previously defined derived type.
 
 program main
   type :: recursive1
     !ERROR: Recursive use of the derived type requires POINTER or ALLOCATABLE
     type(recursive1) :: bad1
     type(recursive1), pointer :: ok1
     type(recursive1), allocatable :: ok2
     !ERROR: Recursive use of the derived type requires POINTER or ALLOCATABLE

flang/test/Semantics/resolve88.f90

+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
+! C746, C747, and C748
+module m
+  use ISO_FORTRAN_ENV
+  use ISO_C_BINDING
+
+  ! C746 If a coarray-spec appears, it shall be a deferred-coshape-spec-list and
+  ! the component shall have the ALLOCATABLE attribute.
+
+  type testCoArrayType
+    real, allocatable, codimension[:] :: allocatableField
+    !ERROR: Component 'deferredfield' is a coarray and must have the ALLOCATABLE attribute
+    real, codimension[:] :: deferredField
+    !ERROR: 'pointerfield' may not have the POINTER attribute because it is a coarray
+    !ERROR: Component 'pointerfield' is a coarray and must have the ALLOCATABLE attribute
+    real, pointer, codimension[:] :: pointerField
+    !ERROR: Component 'realfield' is a coarray and must have the ALLOCATABLE attribute and have a deferred coshape
+    real, codimension[*] :: realField
+    !ERROR: 'realfield2' is an ALLOCATABLE coarray and must have a deferred coshape
+    real, allocatable, codimension[*] :: realField2
+  end type testCoArrayType
+
+  ! C747 If a coarray-spec appears, the component shall not be of type C_PTR or
+  ! C_FUNPTR from the intrinsic module ISO_C_BINDING (18.2), or of type 
+  ! TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV (16.10.2).
+
+  type goodCoarrayType
+    real, allocatable, codimension[:] :: field
+  end type goodCoarrayType
+
+  type goodTeam_typeCoarrayType
+    type(team_type), allocatable :: field
+  end type goodTeam_typeCoarrayType
+
+  type goodC_ptrCoarrayType
+    type(c_ptr), allocatable :: field
+  end type goodC_ptrCoarrayType
+
+  type goodC_funptrCoarrayType
+    type(c_funptr), allocatable :: field
+  end type goodC_funptrCoarrayType
+
+  type team_typeCoarrayType
+    !ERROR: A coarray component may not be of type TEAM_TYPE from ISO_FORTRAN_ENV
+    type(team_type), allocatable, codimension[:] :: field
+  end type team_typeCoarrayType
+
+  type c_ptrCoarrayType
+    !ERROR: A coarray component may not be of type C_PTR or C_FUNPTR from ISO_C_BINDING
+    type(c_ptr), allocatable, codimension[:] :: field
+  end type c_ptrCoarrayType
+
+  type c_funptrCoarrayType
+    !ERROR: A coarray component may not be of type C_PTR or C_FUNPTR from ISO_C_BINDING
+    type(c_funptr), allocatable, codimension[:] :: field
+  end type c_funptrCoarrayType
+
+! C748 A data component whose type has a coarray ultimate component shall be a
+! nonpointer nonallocatable scalar and shall not be a coarray.
+
+  type coarrayType
+    real, allocatable, codimension[:] :: goodCoarrayField
+  end type coarrayType
+
+  type testType
+    type(coarrayType) :: goodField
+    !ERROR: A component with a POINTER or ALLOCATABLE attribute may not be of a type with a coarray ultimate component (named 'goodcoarrayfield')
+    type(coarrayType), pointer :: pointerField
+    !ERROR: A component with a POINTER or ALLOCATABLE attribute may not be of a type with a coarray ultimate component (named 'goodcoarrayfield')
+    type(coarrayType), allocatable :: allocatableField
+    !ERROR: An array or coarray component may not be of a type with a coarray ultimate component (named 'goodcoarrayfield')
+    type(coarrayType), dimension(3) :: arrayField
+  end type testType
+
+end module m

flang/test/Semantics/resolve89.f90

+! RUN: %B/test/Semantics/test_errors.sh %s %flang %t
+! C750 Each bound in the explicit-shape-spec shall be a specification
+! expression in which there are no references to specification functions or
+! the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_- TYPE_OF, PRESENT,
+! or SAME_TYPE_AS, every specification inquiry reference is a constant
+! expression, and the value does not depend on the value of a variable.
+impure function impureFunc()
+  integer :: impureFunc
+
+  impureFunc = 3
+end function impureFunc
+
+pure function pureFunc()
+  integer :: pureFunc
+
+  pureFunc = 3
+end function pureFunc
+
+module m
+  real, allocatable :: mVar
+end module m
+
+subroutine s(iArg, allocArg, pointerArg, arrayArg, ioArg, optionalArg)
+  use m
+  implicit logical(l)
+  integer, intent(in) :: iArg
+  real, allocatable, intent(in) :: allocArg
+  real, pointer, intent(in) :: pointerArg
+  integer, dimension(:), intent(in) :: arrayArg
+  integer, intent(inout) :: ioArg
+  real, optional, intent(in) :: optionalArg
+
+  ! These declarations are OK since they're not in a derived type
+  real :: realVar
+  real, volatile :: volatileVar
+  real, dimension(merge(1, 2, allocated(allocArg))) :: realVar1
+  real, dimension(merge(1, 2, associated(pointerArg))) :: realVar2
+  real, dimension(merge(1, 2, is_contiguous(arrayArg))) :: realVar3
+  real, dimension(ioArg) :: realVar4
+  real, dimension(merge(1, 2, present(optionalArg))) :: realVar5
+
+  ! statement functions referenced below
+  iVolatileStmtFunc() = 3 * volatileVar
+  iImpureStmtFunc() = 3 * impureFunc()
+  iPureStmtFunc() = 3 * pureFunc()
+
+  ! This is OK
+  real, dimension(merge(1, 2, allocated(mVar))) :: rVar
+
+
+  integer :: var = 3
+    !ERROR: Invalid specification expression: reference to impure function 'ivolatilestmtfunc'
+  real, dimension(iVolatileStmtFunc()) :: arrayVarWithVolatile
+    !ERROR: Invalid specification expression: reference to impure function 'iimpurestmtfunc'
+  real, dimension(iImpureStmtFunc()) :: arrayVarWithImpureFunction
+    !ERROR: Invalid specification expression: reference to statement function 'ipurestmtfunc'
+  real, dimension(iPureStmtFunc()) :: arrayVarWithPureFunction
+  real, dimension(iabs(iArg)) :: arrayVarWithIntrinsic
+
+  type arrayType
+    !ERROR: Invalid specification expression: reference to variable 'var' not allowed for derived type components
+    real, dimension(var) :: varField
+    !ERROR: Invalid specification expression: reference to impure function 'ivolatilestmtfunc'
+    real, dimension(iVolatileStmtFunc()) :: arrayFieldWithVolatile
+    !ERROR: Invalid specification expression: reference to impure function 'iimpurestmtfunc'
+    real, dimension(iImpureStmtFunc()) :: arrayFieldWithImpureFunction
+    !ERROR: Invalid specification expression: reference to statement function 'ipurestmtfunc'
+    real, dimension(iPureStmtFunc()) :: arrayFieldWithPureFunction
+    !ERROR: Invalid specification expression: reference to variable 'iarg' not allowed for derived type components
+    real, dimension(iabs(iArg)) :: arrayFieldWithIntrinsic
+    !ERROR: Invalid specification expression: reference to intrinsic 'allocated' not allowed for derived type components
+    real, dimension(merge(1, 2, allocated(allocArg))) :: realField1
+    !ERROR: Invalid specification expression: reference to intrinsic 'associated' not allowed for derived type components
+    real, dimension(merge(1, 2, associated(pointerArg))) :: realField2
+    !ERROR: Invalid specification expression: non-constant reference to inquiry intrinsic 'is_contiguous' not allowed for derived type components
+    real, dimension(merge(1, 2, is_contiguous(arrayArg))) :: realField3
+    !ERROR: Invalid specification expression: reference to variable 'ioarg' not allowed for derived type components
+    real, dimension(ioArg) :: realField4
+    !ERROR: Invalid specification expression: reference to intrinsic 'present' not allowed for derived type components
+    real, dimension(merge(1, 2, present(optionalArg))) :: realField5
+  end type arrayType
+
+end subroutine s
+
+subroutine s1()
+  ! C750, check for a constant specification inquiry that's a type parameter
+  ! inquiry which are defined in 9.4.5
+  type derived(param)
+    integer, len :: param = 3
+  end type
+
+  contains
+    subroutine inner (derivedArg)
+      type(derived), intent(in), dimension(3) :: derivedArg
+      integer :: localInt
+
+      type(derived), parameter :: localderived = derived()
+
+      type localDerivedType
+        ! OK because the specification inquiry is a constant
+        integer, dimension(localDerived%param) :: goodField
+        !ERROR: Invalid specification expression: non-constant reference to a type parameter inquiry not allowed for derived type components
+        integer, dimension(derivedArg%param) :: badField
+      end type localDerivedType
+
+      ! OK because we're not defining a component
+      integer, dimension(derivedArg%param) :: localVar
+    end subroutine inner
+end subroutine s1