[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

248

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

49

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

67

Why '%goodcoarrayfield' rather than 'goodcoarrayfield'?

71

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

[sscalpone]

flang/lib/Evaluate/check-expression.cpp

248

+1 an addition to the intrinsics table

[PeteSteinfeld]

flang/lib/Evaluate/check-expression.cpp

248

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

49

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

67

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.

71

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 ↗

(On Diff #260345)

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

[PeteSteinfeld]

flang/test/Semantics/assign04.f90

9 ↗

(On Diff #260345)

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

public:
   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:
   }
 
   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
+        const std::string badIntrinsicsForComponents{
+            "allocated associated extends_type_of present same_type_as"};
+        if (badIntrinsicsForComponents.find(intrin.name) != std::string::npos) {
+          return "reference to intrinsic '"s + intrin.name +
+              "' not allowed for derived type components";
+        }
+        const std::string inquiryIntrinsics{
+            "allocated associated bit_size coshape digits epsilon "
+            "extends_type_of huge is_contiguous kind lbound lcobound len "
+            "maxexponent minexponent new_line precision present radix range "
+            "rank same_type_as shape size storage_size tiny ubound ucobound"};
+        if (inquiryIntrinsics.find(intrin.name) != std::string::npos &&
+            !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());

flang/lib/Semantics/check-declarations.cpp

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 when an allocatable object is a "
+                "coarray"_err_en_US);
+          }
+        }
+      }
+      if (auto it{FindCoarrayUltimateComponent(*derived)}) { // C748
+        std::string ultimateName{it.BuildResultDesignatorName()};
+        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 SubprogramDetails *funcDetails{symbol.detailsIf<SubprogramDetails>()};
+    if (funcDetails) {
+      const MaybeExpr &expr{funcDetails->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);

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/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 when an allocatable object is a coarray
+    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 when an allocatable object is a coarray
+    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