[flang][driver] Add options for -std=f2018

[arnamoy10]

Summary

Add support for the following Fortran dialect options:

-std=f2018

It also adds one test cases. Currently only f2018 is allowed as the standard.

[tskeith]

Please make sure the test works with f18 also.

flang/lib/Frontend/CompilerInvocation.cpp

397

This should be "f2018", not "2018".

flang/test/Flang-Driver/std2018.f90

18 ↗

(On Diff #325205)

Can you verify this message is not produced when there is no -std option?

[awarzynski]

Hi @arnamoy10 , thank for working on this!

I suggest making it more explicit that the new option is about _enabling standard conformance checks_. So e.g. enableConformanceChecks rather than setStandard (or set_EnableConformanceChecks if the member variable is called EnableConformanceChecks).

I am also mindful that adding -std=f2018 might be a bit confusing to users if we don't support other versions of the language. @tskeith raised this point earlier.

Perhaps we should use e..g -fstd-conf-checks/-fno-std-conf-checks instead? This could be an alias for -Mstandard in f18. We would replace it with -std=<arg> once that makes more sense.

flang/include/flang/Frontend/CompilerInvocation.h

76

Wouldn`t e.g. standardConformanceChecks_ be a bit more self-explanatory? Currently this is quite vague.

124

Missing empty line.

flang/test/Flang-Driver/std2018.f90

12–13 ↗

(On Diff #325205)

[nit] -fstynax-only is effectively the default in the frontend driver, see here. Basically, in the absence of any _action_ options, the driver will run the ParseSyntaxOnly action (which corresponds to -fsyntax-only)

[arnamoy10]

1. Updated the test case to include a check when the option is not given and make sure works with f18 as well (with Mstandard)
2. Changed variable names as suggested.

[richard.barton.arm]

I agree with @tskeith that -Mstandard is not exactly orthogonal to -std, the former being about warning for non-standard extensions/deviations and the latter being about use of standard fortran, but from a different standard version. I would expect -Mstandard to apply to whatever value of -std you gave the compiler.

I think the gfortran analog to -Mstandard is -fpedantic or -fpedantic-errors - see https://gcc.gnu.org/onlinedocs/gfortran/Error-and-Warning-Options.html#Error-and-Warning-Options. The docs have a little joke in them about the feature not doing what users want, but I think that's just a witty way to say that the feature is incomplete, but that it is expected to catch things in theory. So maybe -fpedantic{-errors} is a good thing to substitute for -Mstandard?

FWIW, I think supporting -std with only one supported option is a reasonable thing to do and will help with folks porting codes to flang from gfortran to accept the option and to know what's supported and what is not. Perhaps the perfect thing would be supporting all the sensible gfortran values for -std, but emitting a (downgradable) warning or remark when one that is not supported is given. That would let users know what they are dealing with until the day when flang supports other values for -std. I doubt supporting older versions is on anyone's short-term roadmap, but patches would probably be welcomed on that. I guess there will one day be a -std=f202X option supported too!

[bryanpkc]

I agree with @richard.barton.arm that we could add -std= now, even if only for a subset of possible language standards. I expect that standard conformance checks would be quite pervasive, and it would be better to design the infrastructure for such checks earlier rather than try to retrofit them at a later stage when we have to start supporting f202x, etc.

[arnamoy10]

Updating the patch to make -pedantic and -f2018 behave the same way, also updated the test case accordingly.

[awarzynski]

clang/include/clang/Driver/Options.td

3535–3537

As this options is shared with Clang, the description should be generic enough so that it works for both clang and flang. Some sources for inspiration below:

gfortran 1

gfortran --help=common | grep "\-\-pedantic"
 --pedantic                  Same as -Wpedantic.  Use the latter option instead.
 --pedantic-errors       Same as -pedantic-errors.  Use the latter option instead.

gfortran 2

$ gfortran --help=common | grep "\-Wpedantic "
  -Wpedantic                  Issue warnings needed for strict compliance to the standard.

clang
(from https://clang.llvm.org/docs/UsersManual.html):

-pedantic
Warn on language extensions.

-pedantic-errors
Error on language extensions.

clang/lib/Driver/ToolChains/Flang.cpp

54

-pedantic controls errors and warning messages. It's not really a dialect option.

flang/lib/Frontend/CompilerInvocation.cpp

392–395

DELETEME?

flang/test/Driver/std2018.f90

7–12

We are moving towards sharing all of the tests between the new and the old drivers (more context: https://reviews.llvm.org/D98257). We should avoid:

• %f18, which is meant for f18 only,
• %flang-new, which is meant for flang-new only.

So this whole section is a bit problematic. As these options don't require any particular logic in the compiler driver (i.e. flang-new), I suggest deleting it. It is sufficient to test with the frontend driver %flang_fc1 (i.e. flang-new -fc1).

[arnamoy10]

1. Update the test case to only test flang-new -fc1
2. Updated help text
3. Clang-formatted and also removed redundant code

[tskeith]

flang/test/Driver/std2018.f90

10

You need to make sure these work with f18 or indicate the test requires the new driver. f18 doesn't currently support -std=f2018 and doesn't complain about unrecognized options.

[arnamoy10]

Adding one more update that is probably required in semanticContext (inspired by f18), also updated test case to require flang-driver

[arnamoy10]

Moving -std to non-dialect option

[arnamoy10]

Separating test cases for accepted input option and not accepted input option.

[awarzynski]

flang/test/Driver/std2018.f90

2

Would it be possible to share this test with f18?

flang/test/Driver/std2018_wrong.f90

15–23

No input is needed for this test, is it? IIUC, this bit can be deleted to make the test leaner.

[arnamoy10]

flang/test/Driver/std2018.f90

2

Would you please elaborate on how do want the sharing to happen (same test file/different test file)? I think in a previous comment you mentioned that it is sufficient to test the frontend driver for this patch?

flang/test/Driver/std2018_wrong.f90

15–23

Sure, will do.

[awarzynski]

flang/test/Driver/std2018.f90

2

This line means that the test is not run when FLANG_BUILD_NEW_DRIVER is Off:

! REQUIRES: new-flang-driver

Once this line is removed, the test is effectively shared.

Currently this test won't work with f18(i.e. when you remove this line), but is should be sufficient to add -pedantic and -std=f2018 as aliases for Mstandard.

[arnamoy10]

1. Leaning out the "wrong-option" test case
2. Adding aliases in f18 (-pedantic and -std=2018 for -Mstandard)

[arnamoy10]

Rebasing on top of main

[awarzynski]

Thank you for updating this @arnamoy10!

One thing worth pointing out - this patch adds -pedantic rather than -fpendatic as @richard.barton.arm suggested. That was clearly a typo, so everything is good.

IMO this is ready to land provided that:

• the test is updated to work with f18
• summary/commit message is updated to reflect the recent changes (i.e. that this patch adds -std=f2018 AND -pedantic)

These are small changes and I'm happy for you to apply them when merging (rather than updating here first).

flang/lib/Frontend/CompilerInvocation.cpp

375

[nit] -pedantic instead

535

[nit] Comment inconsistent with the code (no standard is set here)

flang/test/Driver/std2018.f90

7–9

flang-new -fc1 (akin to clang- cc1), runs -fsyntax-only when no other action flag is specified. f18 will go straight into code-generation. As such, this test fails for f18. Adding -fsyntax-only should fix it. It will also make the test a bit more clearer.

[arnamoy10]

Updating test case to add -fsyntax-only to share with f18

clang/include/clang/Driver/Options.td

 def o : JoinedOrSeparate<["-"], "o">, Flags<[NoXarchOption, RenderAsInput,
   CC1Option, CC1AsOption, FC1Option, FlangOption]>,
   HelpText<"Write output to <file>">, MetaVarName<"<file>">,
   MarshallingInfoString<FrontendOpts<"OutputFile">>;
 def pagezero__size : JoinedOrSeparate<["-"], "pagezero_size">;
 def pass_exit_codes : Flag<["-", "--"], "pass-exit-codes">, Flags<[Unsupported]>;
 def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group<pedantic_Group>, Flags<[CC1Option]>,
   MarshallingInfoFlag<DiagnosticOpts<"PedanticErrors">>;
-def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1Option]>,
-  MarshallingInfoFlag<DiagnosticOpts<"Pedantic">>;
+def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1Option,FlangOption,FC1Option]>,
+  HelpText<"Warn on language extensions">, MarshallingInfoFlag<DiagnosticOpts<"Pedantic">>;
 def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>,
   MarshallingInfoFlag<CodeGenOpts<"InstrumentForProfiling">>;
 def pipe : Flag<["-", "--"], "pipe">,
   HelpText<"Use pipes between commands, when possible">;
 def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
 def prebind : Flag<["-"], "prebind">;
 def preload : Flag<["-"], "preload">;
 def print_file_name_EQ : Joined<["-", "--"], "print-file-name=">,
   HelpText<"Print the full library path of <file>">, MetaVarName<"<file>">;

 def shared : Flag<["-", "--"], "shared">, Group<Link_Group>;
 def single__module : Flag<["-"], "single_module">;
 def specs_EQ : Joined<["-", "--"], "specs=">, Group<Link_Group>;
 def specs : Separate<["-", "--"], "specs">, Flags<[Unsupported]>;
 def static_libgcc : Flag<["-"], "static-libgcc">;
 def static_libstdcxx : Flag<["-"], "static-libstdc++">;
 def static : Flag<["-", "--"], "static">, Group<Link_Group>, Flags<[NoArgumentUnused]>;
 def std_default_EQ : Joined<["-"], "std-default=">;
-def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>,
+def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option,FlangOption,FC1Option]>,
   Group<CompileOnly_Group>, HelpText<"Language standard to compile for">,
   ValuesCode<[{
     const char *Values =
     #define LANGSTANDARD(id, name, lang, desc, features) name ","
     #define LANGSTANDARD_ALIAS(id, alias) alias ","
     #include "clang/Basic/LangStandards.def"
     ;
   }]>;

clang/lib/Driver/ToolChains/Flang.cpp

 void Flang::AddPreprocessingOptions(const ArgList &Args,
                                     ArgStringList &CmdArgs) const {
   Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
 }
 
 void Flang::AddOtherOptions(const ArgList &Args, ArgStringList &CmdArgs) const {
   Args.AddAllArgs(CmdArgs,
                   {options::OPT_module_dir, options::OPT_fdebug_module_writer,
-                   options::OPT_fintrinsic_modules_path});
+                   options::OPT_fintrinsic_modules_path, options::OPT_pedantic,
+                   options::OPT_std_EQ});
 }
 
 void Flang::ConstructJob(Compilation &C, const JobAction &JA,
                          const InputInfo &Output, const InputInfoList &Inputs,
                          const ArgList &Args, const char *LinkingOutput) const {
   const auto &TC = getToolChain();
   // TODO: Once code-generation is available, this will need to be commented
   // out.
   // const llvm::Triple &Triple = TC.getEffectiveTriple();
   // const std::string &TripleStr = Triple.getTriple();
 
   ArgStringList CmdArgs;
 
   // Invoke ourselves in -fc1 mode.
   CmdArgs.push_back("-fc1");

flang/include/flang/Frontend/CompilerInvocation.h

 //===- CompilerInvocation.h - Compiler Invocation Helper Data ---*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
 #define LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
 
 #include "flang/Frontend/FrontendOptions.h"
 #include "flang/Frontend/PreprocessorOptions.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Semantics/semantics.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "llvm/Option/ArgList.h"
 #include <memory>
 
class CompilerInvocation : public CompilerInvocationBase {
   // TODO: Merge with or translate to frontendOpts_. We shouldn't need two sets
   // of options.
   std::string moduleDir_ = ".";
 
   bool debugModuleDir_ = false;
 
   // Fortran Dialect options
   Fortran::common::IntrinsicTypeDefaultKinds defaultKinds_;
 
+  bool EnableConformanceChecks_ = false;
+
 public:
   CompilerInvocation() = default;
 
   FrontendOptions &frontendOpts() { return frontendOpts_; }
   const FrontendOptions &frontendOpts() const { return frontendOpts_; }
 
   Fortran::parser::Options &fortranOpts() { return parserOpts_; }
   const Fortran::parser::Options &fortranOpts() const { return parserOpts_; }
 
   Fortran::semantics::SemanticsContext &semanticsContext() {
     return *semanticsContext_;
   }
   const Fortran::semantics::SemanticsContext &semanticsContext() const {
     return *semanticsContext_;
   }
 
   std::string &moduleDir() { return moduleDir_; }
   const std::string &moduleDir() const { return moduleDir_; }
 
   bool &debugModuleDir() { return debugModuleDir_; }
   const bool &debugModuleDir() const { return debugModuleDir_; }
 
+  bool &enableConformanceChecks() { return EnableConformanceChecks_; }
+  const bool &enableConformanceChecks() const {
+    return EnableConformanceChecks_;
+  }
+
   Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds() {
     return defaultKinds_;
   }
   const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds() const {
     return defaultKinds_;
   }
 
   /// Create a compiler invocation from a list of input options.
   /// \returns true on success.
   /// \returns false if an error was encountered while parsing the arguments
   /// \param [out] res - The resulting invocation.
   static bool CreateFromArgs(CompilerInvocation &res,
       llvm::ArrayRef<const char *> commandLineArgs,
       clang::DiagnosticsEngine &diags);
 
+  // Enables the std=f2018 conformance check
+  void set_EnableConformanceChecks() { EnableConformanceChecks_ = true; }
+
   /// Useful setters
   void SetModuleDir(std::string &moduleDir) { moduleDir_ = moduleDir; }
 
   void SetDebugModuleDir(bool flag) { debugModuleDir_ = flag; }
 
   /// Set the Fortran options to predifined defaults. These defaults are
   /// consistend with f18/f18.cpp.
   // TODO: We should map frontendOpts_ to parserOpts_ instead. For that, we
   // need to extend frontendOpts_ first. Next, we need to add the corresponding

flang/lib/Frontend/CompilerInvocation.cpp

 //===- CompilerInvocation.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInvocation.h"
 #include "flang/Common/Fortran-features.h"
 #include "flang/Frontend/PreprocessorOptions.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Version.inc"
 #include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/DriverDiagnostic.h"
static void parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
   }
   if (args.hasArg(clang::driver::options::OPT_fdefault_double_8)) {
     if (!args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
       // -fdefault-double-8 has to be used with -fdefault-real-8
       // to be compatible with gfortran
       const unsigned diagID =
           diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
               "Use of `-fdefault-double-8` requires `-fdefault-real-8`");
       diags.Report(diagID);
     }
     // https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html
     res.defaultKinds().set_doublePrecisionKind(8);
   }
   if (args.hasArg(clang::driver::options::OPT_flarge_sizes))
     res.defaultKinds().set_sizeIntegerKind(8);
 
   // -fopenmp and -fopenacc
   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);
   }
+
+  //-fpedantic
+  if (args.hasArg(clang::driver::options::OPT_pedantic)) {
+    res.set_EnableConformanceChecks();
+  }
+  // -std=f2018.  Current behaviour is same as -fpedantic
+  // TODO: Set proper options when more fortran standards
+  // are supported.
+  if (args.hasArg(clang::driver::options::OPT_std_EQ)) {
+    auto standard = args.getLastArgValue(clang::driver::options::OPT_std_EQ);
+    // We only allow f2018 as the given standard
+    if (standard.equals("f2018")) {
+      res.set_EnableConformanceChecks();
+    } else {
+      const unsigned diagID =
+          diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
+              "Only -std=f2018 is allowed currently.");
+      diags.Report(diagID);
+    }
+  }
   return;
 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
     llvm::ArrayRef<const char *> commandLineArgs,
     clang::DiagnosticsEngine &diags) {
 
   bool success = true;
void CompilerInvocation::setFortranOpts() {
   auto &moduleDirJ = moduleDir();
 
   if (frontendOptions.fortranForm_ != FortranForm::Unknown) {
     fortranOptions.isFixedForm =
         frontendOptions.fortranForm_ == FortranForm::FixedForm;
   }
   fortranOptions.fixedFormColumns = frontendOptions.fixedFormColumns_;
 
   fortranOptions.features = frontendOptions.features_;
   fortranOptions.encoding = frontendOptions.encoding_;
 
   collectMacroDefinitions(preprocessorOptions, fortranOptions);
 
   // Adding search directories specified by -I
   fortranOptions.searchDirectories.insert(
       fortranOptions.searchDirectories.end(),
       preprocessorOptions.searchDirectoriesFromDashI.begin(),
void CompilerInvocation::setFortranOpts() {
 
   // Add the directory supplied through -J/-module-dir to the list of search
   // directories
   if (moduleDirJ.compare(".") != 0)
     fortranOptions.searchDirectories.emplace_back(moduleDirJ);
 
   if (frontendOptions.instrumentedParse_)
     fortranOptions.instrumentedParse = true;
+
+  // Set the standard
+  if (enableConformanceChecks()) {
+    fortranOptions.features.WarnOnAllNonstandard();
+  }
 }
 
 void CompilerInvocation::setSemanticsOpts(
     Fortran::parser::AllCookedSources &allCookedSources) {
   const auto &fortranOptions = fortranOpts();
 
   semanticsContext_ = std::make_unique<semantics::SemanticsContext>(
       defaultKinds(), fortranOptions.features, allCookedSources);
 
   semanticsContext_->set_moduleDirectory(moduleDir())
-      .set_searchDirectories(fortranOptions.searchDirectories);
+      .set_searchDirectories(fortranOptions.searchDirectories)
+      .set_warnOnNonstandardUsage(enableConformanceChecks());
 }

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

 ! CHECK-NEXT: -fno-color-diagnostics Disable colors in diagnostics
 ! 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: -module-dir <dir>      Put MODULE files in <dir>
 ! CHECK-NEXT: -o <file> Write output to <file>
+! CHECK-NEXT: -pedantic              Warn on language extensions
+! CHECK-NEXT: -std=<value>           Language standard to compile for
 ! CHECK-NEXT: -U <macro>             Undefine macro <macro>
 ! CHECK-NEXT: --version Print version information
 ! CHECK-NEXT: -Xflang <arg>          Pass <arg> to the flang compiler
 
 !-------------------------------------------------------------
 ! EXPECTED OUTPUT FOR FLANG DRIVER (flang-new)
 !-------------------------------------------------------------
 ! ERROR-FLANG: error: unknown argument '-help-hidden'; did you mean '--help-hidden'?
 
 !-------------------------------------------------------------
 ! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang-new -fc1)
 !-------------------------------------------------------------
 ! Frontend driver -help-hidden is not supported
 ! ERROR-FLANG-FC1: error: unknown argument: '{{.*}}'
 

flang/test/Driver/driver-help.f90

 ! HELP-NEXT: -fno-color-diagnostics Disable colors in diagnostics
 ! 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: -module-dir <dir>      Put MODULE files in <dir>
 ! HELP-NEXT: -o <file>              Write output to <file>
+! HELP-NEXT: -pedantic              Warn on language extensions
+! HELP-NEXT: -std=<value>           Language standard to compile for
 ! HELP-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-NEXT: --version              Print version information
 ! HELP-NEXT: -Xflang <arg>          Pass <arg> to the flang compiler
 
 !-------------------------------------------------------------
 ! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang-new -fc1)
 !-------------------------------------------------------------
 ! HELP-FC1:USAGE: flang-new

 ! HELP-FC1-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! 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: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-FC1-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! HELP-FC1-NEXT: -o <file>              Write output to <file>
+! HELP-FC1-NEXT: -pedantic              Warn on language extensions
+! HELP-FC1-NEXT: -std=<value>           Language standard to compile for
 ! HELP-FC1-NEXT: -test-io               Run the InputOuputTest action. Use for development and testing only.
 ! HELP-FC1-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-FC1-NEXT: --version              Print version information
 
 !---------------
 ! EXPECTED ERROR
 !---------------
 ! ERROR: error: unknown argument '-helps'; did you mean '-help'

flang/test/Driver/std2018.f90

+! Ensure argument -std=f2018 works as expected.
+
+!-----------------------------------------
+! FRONTEND FLANG DRIVER (flang-new -fc1)
+!-----------------------------------------
+! RUN: %flang_fc1 %s  2>&1 | FileCheck %s --allow-empty --check-prefix=WITHOUT
+! RUN: %flang_fc1 -std=f2018 %s  2>&1 | FileCheck %s --check-prefix=GIVEN
+! RUN: %flang_fc1 -pedantic %s  2>&1 | FileCheck %s --check-prefix=GIVEN
+
+!-----------------------------------------
+! EXPECTED OUTPUT WITHOUT
+!-----------------------------------------
+! WITHOUT-NOT: A DO loop should terminate with an END DO or CONTINUE
+
+!-----------------------------------------
+! EXPECTED OUTPUT WITH
+!-----------------------------------------
+! GIVEN: A DO loop should terminate with an END DO or CONTINUE
+
+subroutine foo2()
+    do 01 m=1,2
+      select case (m)
+      case default
+        print*, "default", m
+      case (1)
+        print*, "start"
+01    end select
+end subroutine

flang/test/Driver/std2018_wrong.f90

+! REQUIRES: new-flang-driver
+! Ensure argument -std=f2018 works as expected.
+
+!-----------------------------------------
+! FRONTEND FLANG DRIVER (flang-new -fc1)
+!-----------------------------------------
+! RUN: not %flang_fc1 -std=90 %s  2>&1 | FileCheck %s --check-prefix=WRONG
+
+!-----------------------------------------
+! EXPECTED OUTPUT WITH WRONG
+!-----------------------------------------
+! WRONG: Only -std=f2018 is allowed currently.

flang/tools/f18/f18.cpp

if (arg.empty()) {
       options.fixedFormColumns = 1000000;
     } else if (arg == "-Mbackslash") {
       options.features.Enable(
           Fortran::common::LanguageFeature::BackslashEscapes, false);
     } else if (arg == "-Mnobackslash") {
       options.features.Enable(
           Fortran::common::LanguageFeature::BackslashEscapes, true);
     } else if (arg == "-Mstandard" || arg == "-std=f95" ||
-        arg == "-std=f2003" || arg == "-std=f2008" || arg == "-std=legacy") {
+        arg == "-std=f2003" || arg == "-std=f2008" || arg == "-std=legacy" ||
+        arg == "-std=f2018" || arg == "-pedantic") {
       driver.warnOnNonstandardUsage = true;
     } else if (arg == "-fopenacc") {
       options.features.Enable(Fortran::common::LanguageFeature::OpenACC);
       predefinitions.emplace_back("_OPENACC", "202011");
     } else if (arg == "-fopenmp") {
       options.features.Enable(Fortran::common::LanguageFeature::OpenMP);
       predefinitions.emplace_back("_OPENMP", "201511");
     } else if (arg == "-Werror") {