[Flang] Add `INTENT` for non-dummy arguments extension

[unterumarmung]

Summary

nvfortran compiler supports using INTENT attributes for non-dummy arguments. For example, for local variables.

This change adds a -fnon-arg-intent flag that enables such behavior in flang.

[unterumarmung]

Fixed revision description

[unterumarmung]

This comment was removed by unterumarmung.

[ekieri]

Hi! Thanks for this patch, and for your interest in contributing to Flang!

I will leave it to somebody more experienced to accept the patch -- I am not familiar with this extension, and am not aware on what grounds we decide which extensions to support. I hope that my suggestions and questions can be useful anyway.

We keep a list of supported extensions in

flang/docs/Extensions.md

Please add this extension there. And please also explain its behaviour a bit.

I wonder about the behaviour. Is INTENT for non-dummies allowed-but-ignored, or does it change the semantics? For example, is an INTENT(IN) variable supposed to be read-only? And what about combining SAVE, INTENT(OUT)? Or PARAMETER, INTENT(INOUT)?

I would also appreciate tests for this behaviour, e.g., a check that modifying an INTENT(IN) non-dummy is allowed or disallowed, as desired.

clang/include/clang/Driver/Options.td

4734–4735

Feel free to use my suggestion literally or to work out something better, whichever you prefer.

flang/lib/Frontend/CompilerInvocation.cpp

536

flang/lib/Semantics/check-declarations.cpp

536

Please check for the feature-enablement together with the INTENT attributes above. Like this, the check for OPTIONAL below might get lost.

771

Same as above.

flang/test/Driver/driver-help-hidden.f90

45

Update description as per above.

flang/test/Driver/driver-help.f90

45

Update description as per above.

119

Update description as per above.

[klausler]

What is going on here? I don't understand.

[unterumarmung]

@ekieri, hello! Thank you for the comment, it is really helpful!
It turns out that I've researched the issue poorly.

Actually, nvfortran compiler forbids to use INTENT attribute on local variables, even though a "mod" file can be generated. It generates a severe error like the one below and there's no way to ignore the severe errors, if I understand correctly.

NVFORTRAN-S-0134-Illegal attribute - intent specified for nondummy argument bar2 (test.f90: 3)

But the reason why I filed the patch was that nvfortran allows to use any kind of INTENT attribute for a local variable that marked as RESULT one for a function:

function foo() result(bar)
    integer, intent(out) :: bar
end function foo

nvfortran does not generate any message for this code, not even a warning. So, it looks like a bug in the compiler, not a feature or extension and this should not be supported in flang, I think.

[ekieri]

Ok, good. Then please abandon this revision (Add Action... down by the comment box), so that its status is clear to everybody. Cheers!

clang/include/clang/Driver/Options.td

def fdefault_double_8 : Flag<["-"],"fdefault-double-8">, Group<f_Group>,
   HelpText<"Set the default double precision kind to an 8 byte wide type">;
 def fdefault_integer_8 : Flag<["-"],"fdefault-integer-8">, Group<f_Group>,
   HelpText<"Set the default integer kind to an 8 byte wide type">;
 def fdefault_real_8 : Flag<["-"],"fdefault-real-8">, Group<f_Group>,
   HelpText<"Set the default real kind to an 8 byte wide type">;
 def flarge_sizes : Flag<["-"],"flarge-sizes">, Group<f_Group>,
   HelpText<"Use INTEGER(KIND=8) for the result type in size-related intrinsics">;
 
+def fnon_arg_intent : Flag<["-"],"fnon-arg-intent">, Group<f_Group>,
+  HelpText<"Allow use of INTENT attribute not for dummy arguments">;
+
 def falternative_parameter_statement : Flag<["-"], "falternative-parameter-statement">, Group<f_Group>,
   HelpText<"Enable the old style PARAMETER statement">;
 def fintrinsic_modules_path : Separate<["-"], "fintrinsic-modules-path">,  Group<f_Group>, MetaVarName<"<dir>">,
   HelpText<"Specify where to find the compiled intrinsic modules">,
   DocBrief<[{This option specifies the location of pre-compiled intrinsic modules,
   if they are not in the default location expected by the compiler.}]>;
 
 defm backslash : OptInFC1FFlag<"backslash", "Specify that backslash in string introduces an escape character">;

clang/lib/Driver/ToolChains/Flang.cpp

 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 void Flang::AddFortranDialectOptions(const ArgList &Args,
                                      ArgStringList &CmdArgs) const {
-  Args.AddAllArgs(
-      CmdArgs, {options::OPT_ffixed_form, options::OPT_ffree_form,
-                options::OPT_ffixed_line_length_EQ, options::OPT_fopenmp,
-                options::OPT_fopenacc, options::OPT_finput_charset_EQ,
-                options::OPT_fimplicit_none, options::OPT_fno_implicit_none,
-                options::OPT_fbackslash, options::OPT_fno_backslash,
+  Args.AddAllArgs(CmdArgs, {options::OPT_ffixed_form,
+                            options::OPT_ffree_form,
+                            options::OPT_ffixed_line_length_EQ,
+                            options::OPT_fopenmp,
+                            options::OPT_fopenacc,
+                            options::OPT_finput_charset_EQ,
+                            options::OPT_fimplicit_none,
+                            options::OPT_fno_implicit_none,
+                            options::OPT_fbackslash,
+                            options::OPT_fno_backslash,
                             options::OPT_flogical_abbreviations,
                             options::OPT_fno_logical_abbreviations,
-                options::OPT_fxor_operator, options::OPT_fno_xor_operator,
+                            options::OPT_fxor_operator,
+                            options::OPT_fno_xor_operator,
                             options::OPT_falternative_parameter_statement,
-                options::OPT_fdefault_real_8, options::OPT_fdefault_integer_8,
-                options::OPT_fdefault_double_8, options::OPT_flarge_sizes,
-                options::OPT_fno_automatic});
+                            options::OPT_fdefault_real_8,
+                            options::OPT_fdefault_integer_8,
+                            options::OPT_fdefault_double_8,
+                            options::OPT_flarge_sizes,
+                            options::OPT_fno_automatic,
+                            options::OPT_fnon_arg_intent});
 }
 
 void Flang::AddPreprocessingOptions(const ArgList &Args,
                                     ArgStringList &CmdArgs) const {
   Args.AddAllArgs(CmdArgs,
                   {options::OPT_P, options::OPT_D, options::OPT_U,
                    options::OPT_I, options::OPT_cpp, options::OPT_nocpp});
 }

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

ENUM_CLASS(LanguageFeature, BackslashEscapes, OldDebugLines,
     OmitFunctionDummies, CrayPointer, Hollerith, ArithmeticIF, Assign,
     AssignedGOTO, Pause, OpenACC, OpenMP, CruftAfterAmpersand, ClassicCComments,
     AdditionalFormats, BigIntLiterals, RealDoControls,
     EquivalenceNumericWithCharacter, EquivalenceNonDefaultNumeric,
     EquivalenceSameNonSequence, AdditionalIntrinsics, AnonymousParents,
     OldLabelDoEndStatements, LogicalIntegerAssignment, EmptySourceFile,
     ProgramReturn, ImplicitNoneTypeNever, ImplicitNoneTypeAlways,
     ForwardRefDummyImplicitNone, OpenAccessAppend, BOZAsDefaultInteger,
-    DistinguishableSpecifics, DefaultSave, PointerInSeqType, NonCharacterFormat)
+    DistinguishableSpecifics, DefaultSave, PointerInSeqType, NonCharacterFormat,
+    NonDummyArgumentIntent)
 
 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);
     disable_.set(LanguageFeature::DefaultSave);
+    disable_.set(LanguageFeature::NonDummyArgumentIntent);
     // 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);
     disable_.set(LanguageFeature::OldStyleParameter);
   }
   LanguageFeatureControl(const LanguageFeatureControl &) = default;

flang/lib/Frontend/CompilerInvocation.cpp

if (args.hasArg(clang::driver::options::OPT_fopenacc)) {
     res.frontendOpts().features.Enable(
         Fortran::common::LanguageFeature::OpenACC);
   }
   if (args.hasArg(clang::driver::options::OPT_fopenmp)) {
     res.frontendOpts().features.Enable(
         Fortran::common::LanguageFeature::OpenMP);
   }
 
+  // -fnv-non-arg-intent
+  if (args.hasArg(clang::driver::options::OPT_fnon_arg_intent)) {
+    res.frontendOpts().features.Enable(
+        Fortran::common::LanguageFeature::NonDummyArgumentIntent);
+  }
+
   // -pedantic
   if (args.hasArg(clang::driver::options::OPT_pedantic)) {
     res.set_EnableConformanceChecks();
   }
   // -std=f2018 (currently this implies -pedantic)
   // TODO: Set proper options when more fortran standards
   // are supported.
   if (args.hasArg(clang::driver::options::OPT_std_EQ)) {

flang/lib/Semantics/check-declarations.cpp

if (InPure() && !IsStmtFunction(DEREF(innermostSymbol_)) &&
       } else if (!IsIntentInOut(symbol)) { // C1586
         messages_.Say(
             "non-POINTER dummy argument of pure subroutine must have INTENT() or VALUE attribute"_err_en_US);
       }
     }
   } else if (symbol.attrs().test(Attr::INTENT_IN) ||
       symbol.attrs().test(Attr::INTENT_OUT) ||
       symbol.attrs().test(Attr::INTENT_INOUT)) {
+    if (!context_.languageFeatures().IsEnabled(
+            Fortran::common::LanguageFeature::NonDummyArgumentIntent))
       messages_.Say("INTENT attributes may apply only to a dummy "
                     "argument"_err_en_US); // C843
   } else if (IsOptional(symbol)) {
     messages_.Say("OPTIONAL attribute may apply only to a dummy "
                   "argument"_err_en_US); // C849
   }
   if (InElemental()) {
     if (details.isDummy()) { // C15100
       if (details.shape().Rank() > 0) {
         messages_.Say(
if (!symbol.attrs().test(Attr::INTRINSIC) &&
       // explicitly forbidden.  But we allow "PROCEDURE(SIN)::dummy"
       // because it is explicitly legal to *pass* the specific intrinsic
       // function SIN as an actual argument.
       messages_.Say("A dummy procedure may not be ELEMENTAL"_err_en_US);
     }
   } else if (symbol.attrs().test(Attr::INTENT_IN) ||
       symbol.attrs().test(Attr::INTENT_OUT) ||
       symbol.attrs().test(Attr::INTENT_INOUT)) {
+    if (!context_.languageFeatures().IsEnabled(
+            Fortran::common::LanguageFeature::NonDummyArgumentIntent))
       messages_.Say("INTENT attributes may apply only to a dummy "
                     "argument"_err_en_US); // C843
   } else if (IsOptional(symbol)) {
     messages_.Say("OPTIONAL attribute may apply only to a dummy "
                   "argument"_err_en_US); // C849
   } else if (symbol.owner().IsDerivedType()) {
     if (!symbol.attrs().test(Attr::POINTER)) { // C756
       const auto &name{symbol.name()};
       messages_.Say(name,
           "Procedure component '%s' must have POINTER attribute"_err_en_US,

flang/test/Driver/driver-help-hidden.f90

 ! CHECK-NEXT: -fimplicit-none        No implicit typing allowed unless overridden by IMPLICIT statements
 ! CHECK-NEXT: -finput-charset=<value> Specify the default character set for source files
 ! CHECK-NEXT: -fintrinsic-modules-path <dir>
 ! CHECK-NEXT:                        Specify where to find the compiled intrinsic modules
 ! CHECK-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! CHECK-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! CHECK-NEXT: -fno-automatic         Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
 ! CHECK-NEXT: -fno-color-diagnostics  Disable colors in diagnostics
+! CHECK-NEXT: -fnon-arg-intent     Allow use of INTENT attribute not for dummy arguments
 ! CHECK-NEXT: -fopenacc              Enable OpenACC
 ! CHECK-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! CHECK-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
 ! CHECK-NEXT: -help     Display available options
 ! CHECK-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! CHECK-NEXT: -mllvm <value>         Additional arguments to forward to LLVM's option processing
 ! CHECK-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! CHECK-NEXT: -nocpp                 Disable predefined and command line preprocessor macros

flang/test/Driver/driver-help.f90

 ! HELP-NEXT: -fimplicit-none        No implicit typing allowed unless overridden by IMPLICIT statements
 ! HELP-NEXT: -finput-charset=<value> Specify the default character set for source files
 ! HELP-NEXT: -fintrinsic-modules-path <dir>
 ! HELP-NEXT:                        Specify where to find the compiled intrinsic modules
 ! HELP-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! HELP-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! HELP-NEXT: -fno-automatic         Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
 ! HELP-NEXT: -fno-color-diagnostics  Disable colors in diagnostics
+! HELP-NEXT: -fnon-arg-intent     Allow use of INTENT attribute not for dummy arguments
 ! HELP-NEXT: -fopenacc              Enable OpenACC
 ! HELP-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
 ! HELP-NEXT: -help                  Display available options
 ! HELP-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-NEXT: -mllvm <value>         Additional arguments to forward to LLVM's option processing
 ! HELP-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! HELP-NEXT: -nocpp                 Disable predefined and command line preprocessor macros

 ! HELP-FC1-NEXT: -fintrinsic-modules-path <dir>
 ! HELP-FC1-NEXT:                        Specify where to find the compiled intrinsic modules
 ! HELP-FC1-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! HELP-FC1-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! HELP-FC1-NEXT: -fno-analyzed-objects-for-unparse
 ! HELP-FC1-NEXT:                        Do not use the analyzed objects when unparsing
 ! HELP-FC1-NEXT: -fno-automatic         Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
 ! HELP-FC1-NEXT: -fno-reformat          Dump the cooked character stream in -E mode
+! HELP-FC1-NEXT: -fnon-arg-intent       Allow use of INTENT attribute not for dummy arguments
 ! HELP-FC1-NEXT: -fopenacc              Enable OpenACC
 ! HELP-FC1-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-FC1-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
 ! HELP-FC1-NEXT: -help                  Display available options
 ! HELP-FC1-NEXT: -init-only             Only execute frontend initialization
 ! HELP-FC1-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-FC1-NEXT: -load <dsopath>        Load the named plugin (dynamic shared object)
 ! HELP-FC1-NEXT: -mllvm <value>         Additional arguments to forward to LLVM's option processing

flang/test/Driver/frontend-forwarding.f90

 ! Test that flang-new forwards Flang frontend
 ! options to flang-new -fc1 as expected.
 
 ! RUN: %flang -fsyntax-only -### %s -o %t 2>&1 \
 ! RUN:     -finput-charset=utf-8 \
 ! RUN:     -fdefault-double-8 \
 ! RUN:     -fdefault-integer-8 \
 ! RUN:     -fdefault-real-8 \
 ! RUN:     -flarge-sizes \
+! RUN:     -fnon-arg-intent \
 ! RUN:     -mllvm -print-before-all\
 ! RUN:     -P \
 ! RUN:   | FileCheck %s
 
 ! CHECK: "-P"
 ! CHECK: "-finput-charset=utf-8"
 ! CHECK: "-fdefault-double-8"
 ! CHECK: "-fdefault-integer-8"
 ! CHECK: "-fdefault-real-8"
 ! CHECK: "-flarge-sizes"
+! CHECK: "-fnon-arg-intent"
 ! CHECK:  "-mllvm" "-print-before-all"

flang/test/Semantics/non-arg-intent.f90

+!RUN: %flang_fc1 %s -fnon-arg-intent
+function foo() result(res)
+    integer, intent(out) :: res
+    procedure(), intent(in) :: p1
+end function foo
 No newline at end of file