[flang] Check for undefined derived types

[PeteSteinfeld]

Summary

It's possible to specify refer to an undefined derived type as the type of a
component of another derived type and then never define the type of the
component. We were not detecting this situation. To fix this, I added
a field to the symbol's DerivedTypeDetails and checked for it when
performing other derived type checks.

I also had to record the fact that error messages were previously
emitted for the same problem in some cases so that I could avoid
duplicate messages.

I also added a test.

[klausler]

flang/include/flang/Semantics/symbol.h

293

Is isDefined_ needed? If a type symbol is created due to a forward reference, isForwardReferenced_ will be set; maybe you can clear it when/if the type is defined, and then just test that flag later.

[PeteSteinfeld]

flang/include/flang/Semantics/symbol.h

293

Good idea. New update coming ...

[PeteSteinfeld]

Responding to comments from Peter.

flang/include/flang/Semantics/symbol.h

public:
   bool sequence() const { return sequence_; }
   std::map<SourceName, SymbolRef> &finals() { return finals_; }
   const std::map<SourceName, SymbolRef> &finals() const { return finals_; }
   bool isForwardReferenced() const { return isForwardReferenced_; }
   void add_paramName(const SourceName &name) { paramNames_.push_back(name); }
   void add_paramDecl(const Symbol &symbol) { paramDecls_.push_back(symbol); }
   void add_component(const Symbol &);
   void set_sequence(bool x = true) { sequence_ = x; }
-  void set_isForwardReferenced() { isForwardReferenced_ = true; }
+  void set_isForwardReferenced(bool value) { isForwardReferenced_ = value; }
   const std::list<SourceName> &componentNames() const {
     return componentNames_;
   }
 
   // If this derived type extends another, locate the parent component's symbol.
   const Symbol *GetParentComponent(const Scope &) const;
 
   std::optional<SourceName> GetParentComponentName() const {
private:
   std::list<SourceName> paramNames_;
   SymbolVector paramDecls_;
   // These are the names of the derived type's components in component
   // order.  A parent component, if any, appears first in this list.
   std::list<SourceName> componentNames_;
   std::map<SourceName, SymbolRef> finals_; // FINAL :: subr
   bool sequence_{false};
   bool isForwardReferenced_{false};
   friend llvm::raw_ostream &operator<<(
       llvm::raw_ostream &, const DerivedTypeDetails &);
 };
 
 class ProcBindingDetails : public WithPassArg {
 public:
   explicit ProcBindingDetails(const Symbol &symbol) : symbol_{symbol} {}
   const Symbol &symbol() const { return symbol_; }
 

flang/lib/Semantics/check-declarations.cpp

if (error) {
         }
       }
     }
   }
 }
 
 void CheckHelper::CheckDerivedType(
     const Symbol &derivedType, const DerivedTypeDetails &details) {
+  if (details.isForwardReferenced() && !context_.HasError(derivedType)) {
+    messages_.Say("The derived type '%s' has not been defined"_err_en_US,
+        derivedType.name());
+  }
   const Scope *scope{derivedType.scope()};
   if (!scope) {
     CHECK(details.isForwardReferenced());
     return;
   }
   CHECK(scope->symbol() == &derivedType);
   CHECK(scope->IsDerivedType());
   if (derivedType.attrs().test(Attr::ABSTRACT) && // C734

flang/lib/Semantics/resolve-names.cpp

 bool DeclarationVisitor::Pre(const parser::DerivedTypeDef &x) {
   auto &stmt{std::get<parser::Statement<parser::DerivedTypeStmt>>(x.t)};
   Walk(stmt);
   Walk(std::get<std::list<parser::Statement<parser::TypeParamDefStmt>>>(x.t));
   auto &scope{currScope()};
   CHECK(scope.symbol());
   CHECK(scope.symbol()->scope() == &scope);
   auto &details{scope.symbol()->get<DerivedTypeDetails>()};
+  details.set_isForwardReferenced(false);
   std::set<SourceName> paramNames;
   for (auto &paramName : std::get<std::list<parser::Name>>(stmt.statement.t)) {
     details.add_paramName(paramName.source);
     auto *symbol{FindInScope(scope, paramName)};
     if (!symbol) {
       Say(paramName,
           "No definition found for type parameter '%s'"_err_en_US); // C742
       // No symbol for a type param.  Create one and mark it as containing an
std::optional<DerivedTypeSpec> DeclarationVisitor::ResolveDerivedType(
   Symbol *symbol{FindSymbol(NonDerivedTypeScope(), name)};
   if (!symbol || symbol->has<UnknownDetails>()) {
     if (allowForwardReferenceToDerivedType()) {
       if (!symbol) {
         symbol = &MakeSymbol(InclusiveScope(), name.source, Attrs{});
         Resolve(name, *symbol);
       };
       DerivedTypeDetails details;
-      details.set_isForwardReferenced();
+      details.set_isForwardReferenced(true);
       symbol->set_details(std::move(details));
     } else { // C732
       Say(name, "Derived type '%s' not found"_err_en_US);
       return std::nullopt;
     }
   }
   if (CheckUseError(name)) {
     return std::nullopt;

flang/lib/Semantics/type.cpp

void DerivedTypeSpec::Instantiate(Scope &containingScope) {
   }
   instantiated_ = true;
   auto &context{containingScope.context()};
   auto &foldingContext{context.foldingContext()};
   if (IsForwardReferenced()) {
     foldingContext.messages().Say(typeSymbol_.name(),
         "The derived type '%s' was forward-referenced but not defined"_err_en_US,
         typeSymbol_.name());
+    context.SetError(typeSymbol_);
     return;
   }
   EvaluateParameters(context);
   const Scope &typeScope{DEREF(typeSymbol_.scope())};
   if (!MightBeParameterized()) {
     scope_ = &typeScope;
     for (auto &pair : typeScope) {
       Symbol &symbol{*pair.second};

flang/test/Semantics/bad-forward-type.f90

type con
     Type(t(3)), pointer :: y
   end type
   !ERROR: Cannot construct value for derived type 't' before it is defined
   Integer :: nn = Size(Transfer(t(3)(666),[0]))
   type :: t(n)
     integer, kind :: n = 3
   end type
 end subroutine s9
+
+subroutine s10
+  type t
+    !ERROR: The derived type 'undef' has not been defined
+    type(undef), pointer :: y
+  end type
+end subroutine s10