[flang] Diagnose invalid initializations

[klausler]

Summary

f18 current ignores attempts to initialize (with =expr) things
that are not objects, or allows meaningless initializations of
things that have mistakenly been promoted to be objects.
Fix by refusing to promote to objects names that have any
attributes that cannot be applied to objects, and then catch
data initializations of symbols that are not objects.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Semantics/resolve-names.cpp

void ScopeHandler::CheckEntryDummyUse(SourceName source, Symbol *symbol) {
   }
 }
 
 // Convert symbol to be a ObjectEntity or return false if it can't be.
 bool ScopeHandler::ConvertToObjectEntity(Symbol &symbol) {
   if (symbol.has<ObjectEntityDetails>()) {
     // nothing to do
   } else if (symbol.has<UnknownDetails>()) {
+    // These are attributes that a name could have picked up from
+    // an attribute statement or type declaration statement.
+    if (symbol.attrs().HasAny({Attr::EXTERNAL, Attr::INTRINSIC})) {
+      return false;
+    }
     symbol.set_details(ObjectEntityDetails{});
   } else if (auto *details{symbol.detailsIf<EntityDetails>()}) {
+    if (symbol.attrs().HasAny({Attr::EXTERNAL, Attr::INTRINSIC})) {
+      return false;
+    }
     funcResultStack_.CompleteTypeIfFunctionResult(symbol);
     symbol.set_details(ObjectEntityDetails{std::move(*details)});
   } else if (auto *useDetails{symbol.detailsIf<UseDetails>()}) {
     return useDetails->symbol().has<ObjectEntityDetails>();
   } else if (auto *hostDetails{symbol.detailsIf<HostAssocDetails>()}) {
     return hostDetails->symbol().has<ObjectEntityDetails>();
   } else {
     return false;
void DeclarationVisitor::Initialization(const parser::Name &name,
     const parser::Initialization &init, bool inComponentDecl) {
   // Traversal of the initializer was deferred to here so that the
   // symbol being declared can be available for use in the expression, e.g.:
   //   real, parameter :: x = tiny(x)
   if (!name.symbol) {
     return;
   }
   Symbol &ultimate{name.symbol->GetUltimate()};
-  if (IsAllocatable(ultimate)) {
-    Say(name, "Allocatable object '%s' cannot be initialized"_err_en_US);
-    return;
-  }
   // TODO: check C762 - all bounds and type parameters of component
   // are colons or constant expressions if component is initialized
   common::visit(
       common::visitors{
           [&](const parser::ConstantExpr &expr) {
             NonPointerInitialization(name, expr);
           },
           [&](const parser::NullInit &null) { // => NULL()
void DeclarationVisitor::NonPointerInitialization(
   if (name.symbol) {
     Symbol &ultimate{name.symbol->GetUltimate()};
     if (!context().HasError(ultimate) && !context().HasError(name.symbol)) {
       if (IsPointer(ultimate)) {
         Say(name,
             "'%s' is a pointer but is not initialized like one"_err_en_US);
       } else if (auto *details{ultimate.detailsIf<ObjectEntityDetails>()}) {
         CHECK(!details->init());
+        if (IsAllocatable(ultimate)) {
+          Say(name, "Allocatable object '%s' cannot be initialized"_err_en_US);
+          return;
+        }
         Walk(expr);
         if (ultimate.owner().IsParameterizedDerivedType()) {
           // Save the expression for per-instantiation analysis.
           details->set_unanalyzedPDTComponentInit(&expr.thing.value());
         } else {
           if (MaybeExpr folded{EvaluateNonPointerInitializer(
                   ultimate, expr, expr.thing.value().source)}) {
             details->set_init(std::move(*folded));
           }
         }
+      } else {
+        Say(name, "'%s' is not an object that can be initialized"_err_en_US);
       }
     }
   }
 }
 
 void ResolveNamesVisitor::HandleCall(
     Symbol::Flag procFlag, const parser::Call &call) {
   common::visit(

flang/test/Semantics/init01.f90

!ERROR: Pointer has rank 1 but target has rank 0
   real, pointer :: p10 => o3%x
   associate (a1 => o3, a2 => o3%x)
     block
       real, pointer :: p11 => a1
       real, pointer :: p12 => a2
     end block
   end associate
 end subroutine
+
+subroutine notObjects
+!ERROR: 'x1' is not an object that can be initialized
+  real, external :: x1 = 1.
+!ERROR: 'x2' is not a pointer but is initialized like one
+  real, external :: x2 => sin
+!ERROR: 'x3' is not an object that can be initialized
+  real, intrinsic :: x3 = 1.
+!ERROR: 'x4' is not a pointer but is initialized like one
+  real, intrinsic :: x4 => cos
+end subroutine