[flang] Add options to control IMPLICIT NONE

[tskeith]

Summary

Add -fimplicit-none-type-always to treat each specification-part
like it has IMPLICIT NONE. This is helpful for enforcing good Fortran
programming practices. We might consider something similar for
IMPLICIT NONE(EXTERNAL) as well.

Add -fimplicit-none-type-never to ignore occurrences of IMPLICIT NONE
and IMPLICIT NONE(TYPE). This is to handle cases like the one below,
which violates the standard but it accepted by some compilers:

subroutine s(a, n)
  implicit none
  real :: a(n)
  integer :: n
end

[sscalpone]

The gfortran options is -fimplicit-none. It doesn't appear to have an inverse, but following the convention would be -fno-implicit-none. I think there is value using the same spelling for this option.

[klausler]

In D85363#2197824, @sscalpone wrote:

The gfortran options is -fimplicit-none. It doesn't appear to have an inverse, but following the convention would be -fno-implicit-none. I think there is value using the same spelling for this option.

But -fno-implicit-none would mean "don't assume IMPLICIT NONE where it doesn't appear", not "ignore IMPLICIT NONE where it does appear." Not the same thing.

[tskeith]

In D85363#2197834, @klausler wrote:

In D85363#2197824, @sscalpone wrote:

The gfortran options is -fimplicit-none. It doesn't appear to have an inverse, but following the convention would be -fno-implicit-none. I think there is value using the same spelling for this option.

But -fno-implicit-none would mean "don't assume IMPLICIT NONE where it doesn't appear", not "ignore IMPLICIT NONE where it does appear." Not the same thing.

We may also want an option that means "assume IMPLICIT NONE(EXTERNAL)" everywhere. That's why I included "type" in the option name. gfortran's -fimplicit-none option may pre-date the addition of IMPLICIT NONE(EXTERNAL) to the language.

Also, we can reconsider option names when we have a real driver.

[sscalpone]

OK

flang/documentation/Extensions.md

* The default `INTEGER` type is required by the standard to occupy
   `REAL` is of course 32-bit IEEE-754 floating-point today.  This legacy
   rule imposes an artificially small constraint in some cases
   where Fortran mandates that something have the default `INTEGER`
   type: specifically, the results of references to the intrinsic functions
   `SIZE`, `LBOUND`, `UBOUND`, `SHAPE`, and the location reductions
   `FINDLOC`, `MAXLOC`, and `MINLOC` in the absence of an explicit
   `KIND=` actual argument.  We return `INTEGER(KIND=8)` by default in
   these cases when the `-flarge-sizes` option is enabled.
+* Treat each specification-part like is has `IMPLICIT NONE`
+  [-fimplicit-none-type-always]
+* Ignore occurrences of `IMPLICIT NONE` and `IMPLICIT NONE(TYPE)`
+  [-fimplicit-none-type-never]
 
 Extensions and legacy features deliberately not supported
 ---------------------------------------------------------
 * `.LG.` as synonym for `.NE.`
 * `REDIMENSION`
 * Allocatable `COMMON`
 * Expressions in formats
 * `ACCEPT` as synonym for `READ *`

flang/include/flang/Common/Fortran-features.h

ENUM_CLASS(LanguageFeature, BackslashEscapes, OldDebugLines,
     TripletInArrayConstructor, MissingColons, SignedComplexLiteral,
     OldStyleParameter, ComplexConstructor, PercentLOC, SignedPrimary, FileName,
     Convert, Dispose, IOListLeadingComma, AbbreviatedEditDescriptor,
     ProgramParentheses, PercentRefAndVal, OmitFunctionDummies, CrayPointer,
     Hollerith, ArithmeticIF, Assign, AssignedGOTO, Pause, OpenACC, OpenMP,
     CruftAfterAmpersand, ClassicCComments, AdditionalFormats, BigIntLiterals,
     RealDoControls, EquivalenceNumericWithCharacter, AdditionalIntrinsics,
     AnonymousParents, OldLabelDoEndStatements, LogicalIntegerAssignment,
-    EmptySourceFile, ProgramReturn)
+    EmptySourceFile, ProgramReturn, ImplicitNoneTypeNever,
+    ImplicitNoneTypeAlways)
 
 using LanguageFeatures = EnumSet<LanguageFeature, LanguageFeature_enumSize>;
 
 class LanguageFeatureControl {
 public:
   LanguageFeatureControl() {
     // These features must be explicitly enabled by command line options.
     disable_.set(LanguageFeature::OldDebugLines);
     disable_.set(LanguageFeature::OpenACC);
     disable_.set(LanguageFeature::OpenMP);
+    disable_.set(LanguageFeature::ImplicitNoneTypeNever);
+    disable_.set(LanguageFeature::ImplicitNoneTypeAlways);
     // These features, if enabled, conflict with valid standard usage,
     // so there are disabled here by default.
     disable_.set(LanguageFeature::BackslashEscapes);
     disable_.set(LanguageFeature::LogicalAbbreviations);
     disable_.set(LanguageFeature::XOROperator);
   }
   LanguageFeatureControl(const LanguageFeatureControl &) = default;
   void Enable(LanguageFeature f, bool yes = true) { disable_.set(f, !yes); }

flang/lib/Semantics/resolve-names.cpp

void SetTypeMapping(const DeclTypeSpec &type, parser::Location fromLetter,
       parser::Location toLetter);
 
 private:
   static char Incr(char ch);
 
   ImplicitRules *parent_;
   SemanticsContext &context_;
   bool inheritFromParent_{false}; // look in parent if not specified here
-  bool isImplicitNoneType_{false};
+  bool isImplicitNoneType_{
+      context_.IsEnabled(common::LanguageFeature::ImplicitNoneTypeAlways)};
   bool isImplicitNoneExternal_{false};
   // map_ contains the mapping between letters and types that were defined
   // by the IMPLICIT statements of the related scope. It does not contain
   // the default Fortran mappings nor the mapping defined in parents.
   std::map<char, common::Reference<const DeclTypeSpec>> map_;
 
   friend llvm::raw_ostream &operator<<(
       llvm::raw_ostream &, const ImplicitRules &);
bool result{
                      [&](const std::list<ImplicitNoneNameSpec> &y) {
                        return HandleImplicitNone(y);
                      },
                      [&](const std::list<parser::ImplicitSpec> &) {
                        if (prevImplicitNoneType_) {
                          Say("IMPLICIT statement after IMPLICIT NONE or "
                              "IMPLICIT NONE(TYPE) statement"_err_en_US);
                          return false;
-                       } else {
-                         implicitRules().set_isImplicitNoneType(false);
                        }
+                       implicitRules().set_isImplicitNoneType(false);
                        return true;
                      },
                  },
           x.u)};
   prevImplicit_ = currStmtSource();
   return result;
 }
 
if (prevImplicitNone_) {
     Say(*prevImplicitNone_, "Previous IMPLICIT NONE statement"_en_US);
     return false;
   }
   if (prevParameterStmt_) {
     Say("IMPLICIT NONE statement after PARAMETER statement"_err_en_US);
     return false;
   }
   prevImplicitNone_ = currStmtSource();
+  bool implicitNoneTypeNever{
+      context().IsEnabled(common::LanguageFeature::ImplicitNoneTypeNever)};
   if (nameSpecs.empty()) {
+    if (!implicitNoneTypeNever) {
       prevImplicitNoneType_ = currStmtSource();
       implicitRules().set_isImplicitNoneType(true);
       if (prevImplicit_) {
         Say("IMPLICIT NONE statement after IMPLICIT statement"_err_en_US);
         return false;
       }
+    }
   } else {
     int sawType{0};
     int sawExternal{0};
     for (const auto noneSpec : nameSpecs) {
       switch (noneSpec) {
       case ImplicitNoneNameSpec::External:
         implicitRules().set_isImplicitNoneExternal(true);
         ++sawExternal;
         break;
       case ImplicitNoneNameSpec::Type:
+        if (!implicitNoneTypeNever) {
           prevImplicitNoneType_ = currStmtSource();
           implicitRules().set_isImplicitNoneType(true);
           if (prevImplicit_) {
             Say("IMPLICIT NONE(TYPE) after IMPLICIT statement"_err_en_US);
             return false;
           }
           ++sawType;
+        }
         break;
       }
     }
     if (sawType > 1) {
       Say("TYPE specified more than once in IMPLICIT NONE statement"_err_en_US);
       return false;
     }
     if (sawExternal > 1) {

flang/test/Semantics/implicit09.f90

+! RUN: %S/test_errors.sh %s %t %f18 -fimplicit-none-type-never
+subroutine s1
+  implicit none
+  i = j + k  ! would be error without -fimplicit-none-type-never
+end
+
+subroutine s2(a, n)
+  implicit none
+  real :: a(n)  ! would be error without -fimplicit-none-type-never
+  integer :: n
+end

flang/test/Semantics/implicit10.f90

+! RUN: %S/test_errors.sh %s %t %f18 -fimplicit-none-type-always
+
+!ERROR: No explicit type declared for 'f'
+function f()
+  !ERROR: No explicit type declared for 'x'
+  f = x
+end

flang/tools/f18/f18.cpp

while (!args.empty()) {
     } else if (arg == "-fxor-operator" || arg == "-fno-xor-operator") {
       options.features.Enable(Fortran::common::LanguageFeature::XOROperator,
           arg == "-fxor-operator");
     } else if (arg == "-flogical-abbreviations" ||
         arg == "-fno-logical-abbreviations") {
       options.features.Enable(
           Fortran::parser::LanguageFeature::LogicalAbbreviations,
           arg == "-flogical-abbreviations");
+    } else if (arg == "-fimplicit-none-type-always") {
+      options.features.Enable(
+          Fortran::common::LanguageFeature::ImplicitNoneTypeAlways);
+    } else if (arg == "-fimplicit-none-type-never") {
+      options.features.Enable(
+          Fortran::common::LanguageFeature::ImplicitNoneTypeNever);
     } else if (arg == "-fdebug-dump-provenance") {
       driver.dumpProvenance = true;
       options.needProvenanceRangeToCharBlockMappings = true;
     } else if (arg == "-fdebug-dump-parse-tree") {
       driver.dumpParseTree = true;
     } else if (arg == "-fdebug-pre-fir-tree") {
       driver.dumpPreFirTree = true;
     } else if (arg == "-fdebug-dump-symbols") {
if (arg.empty()) {
         }
         args.pop_front();
       }
       driver.getDefinitionArgs = {arguments[0], arguments[1], arguments[2]};
     } else if (arg == "-fget-symbols-sources") {
       driver.getSymbolsSources = true;
     } else if (arg == "-byteswapio") {
       driver.byteswapio = true; // TODO: Pass to lowering, generate call
-    } else if (arg == "-h" || arg == "-help" || arg == "--help" || arg == "-?") {
+    } else if (arg == "-h" || arg == "-help" || arg == "--help" ||
+        arg == "-?") {
       llvm::errs()
           << "f18: LLVM Fortran compiler\n"
           << "\n"
           << "Usage: f18 [options] <input files>\n"
           << "\n"
           << "Defaults:\n"
           << "  When invoked with input files, and no options to tell\n"
           << "  it otherwise, f18 will unparse its input and pass that on to an\n"