[flang][driver] Add support for `-fsyntax-only`

[awarzynski]

Summary

The behaviour triggered with this flag is consistent with -fparse-only in flang (i.e. the throwaway driver). This new spelling is consistent with Clang and gfortran, and was proposed and agreed on for the new driver in [1].

[1] http://lists.llvm.org/pipermail/flang-dev/2020-November/000588.html

[kiranchandramohan]

A few comments.

clang/lib/Driver/ToolChains/Flang.cpp

43–44

Why?

flang/include/flang/Frontend/CompilerInstance.h

32

Nit: Semaantics -> Semantics

103–107

What is the coding style of this file?

flang/lib/Frontend/CMakeLists.txt

16

Is Evaluate needed?

flang/lib/Frontend/FrontendActions.cpp

81

What is the use of output stream here?

82

Will the Prescan step have happened before?

84

Nit: semantincs -> semantics

flang/test/Flang-Driver/syntax-only.f90

1

should there be a test without fc1?

[sameeranjoshi]

Thanks for patch, a few queries below.

Are the tests in clang which are related to flang failing at https://reviews.llvm.org/B81474?

flang/include/flang/Frontend/FrontendActions.h

29

Do you think following a pattern here for mapping with enum ActionKind would be better?
something like ParseSyntaxOnlyAction ?

flang/include/flang/Frontend/FrontendOptions.h

1

C++ ?

flang/lib/Frontend/FrontendActions.cpp

96

What happens in case one of the stages in the pipeline fails?
Where is the error recovery done for e.g if parsing fails ?

flang/unittests/Frontend/PrintPreprocessedTest.cpp

121

Execute

[awarzynski]

Thank you for your reviews! I'll submit an updated patch shortly.

clang/lib/Driver/ToolChains/Flang.cpp

43–44

These 2 lines mean that flang-new -fsyntax-only is translated to flang-new -fc1 -fsyntax-only -triple <triple>. However,

$ bin/flang-new -fc1 -triple
error: unknown argument: '-triple'

i.e. the compiler frontend driver, flang-new -fc1, doesn't support this flag.

I extracted this change here: https://reviews.llvm.org/D93027. Also updated the tests that rely on this. Thanks for pointing those failures @sameeranjoshi!

flang/include/flang/Frontend/CompilerInstance.h

103–107

https://github.com/llvm/llvm-project/blob/main/flang/docs/C%2B%2Bstyle.md

flang/include/flang/Frontend/FrontendActions.h

29

Yes, that would be better, thanks!

flang/lib/Frontend/CMakeLists.txt

16

Don't think so. I built with -DBUILD_SHARED_LIBS=On, which usually is pretty good at catching missing CMake dependencies.

flang/lib/Frontend/FrontendActions.cpp

81

In set_debugOutput: https://github.com/llvm/llvm-project/blob/1365718778b4ce05587afa22835282c5d3f835b7/flang/lib/Parser/parsing.cpp#L113. Ideally this should go via some diagnostics engine.

82

Prescan happens here: https://github.com/llvm/llvm-project/blob/1365718778b4ce05587afa22835282c5d3f835b7/flang/lib/Frontend/FrontendAction.cpp#L53. ExecuteAction (i.e. this method) is the next step.

96

That's a great catch, thank you!

flang/test/Flang-Driver/syntax-only.f90

1

This is a tricky question :) The answer depends on what we want to test here:

• fronted driver (flang-new -fc1),
• compiler driver (flang-new),
• Flang frontend, or
• libclangDriver?

In general flang-new -fsyntax-only != flang-new -fc1 -fsyntax-only. Admittedly, currently these are actually equal. However, if you compare clang -### -fsyntax-only and clang -cc1 -fsyntax-only then you will see a rather huge difference. flang-new is also heading in that direction.

To me -fsyntax-only is actually a frontend driver flag. If we also test flang-new -fsyntax-only then that triggers quite a few code-paths within libclangDriver. But this patch doesn't really touch that logic. Instead, it adds some logic in the frontend driver and hence IMO it should be testing the frontend driver only.

But one can argue that from user's perspective:

• flang-new -fc1 -fsyntax-only input.f, and
• flang-new input.f

should be identical. But then again, are we verifying that the user gets what they expect or the internal implementation?

Separately, the fact that libclangDriver _forwards_ -fsyntax-only to flang-new -fc1 is tested here: https://github.com/llvm/llvm-project/blob/1365718778b4ce05587afa22835282c5d3f835b7/clang/test/Driver/flang/flang.f90#L16. (it's a bit more nuanced, that option is not really forwarded, but that's an implementation detail).

[awarzynski]

Update according to PR comments

• extracted the -triple related part into https://reviews.llvm.org/D93027
• made sure that flang-new and flang-new -fc1 return error when semantic checks fail
• fixed typos

[awarzynski]

Fine-tune the output for consistency with flang/f18

This is just a minor change to make sure that:

• flang-new -fc1 -fsyntax-only, and
• f18 -fparse-only

are as similar as possible.

[sameeranjoshi]

Looks good from my end.
Thank you.

[CarolineConcatto]

flang/lib/Frontend/FrontendActions.cpp

87

Just a quick question:
Why you cannot use this function:
CompilerInvocation::SetDefaultFortranOpts
instead of using semanticsContext.set_moduleDirectory("."s);
?

[awarzynski]

flang/lib/Frontend/FrontendActions.cpp

87

Hard-coded values are bad, thanks for pointing that out!

We can't use CompilerInvocation::SetDefaultFortranOpts here, as that's for Fortran::parser::Options, and here we are dealing with the internal state of Fortran::semantics::SemanticsContext.

However, moduleDirectory_ is in fact initialised to "."s by default: https://github.com/llvm/llvm-project/blob/8acb5f2723ecaf0f1904a085ad79d0623cec38f6/flang/include/flang/Semantics/semantics.h#L185.

So, it's safe to delete this line for now. A proper solution/approach will be implemented once we add support for -module-dir: https://docs.google.com/spreadsheets/d/1JRe39lP_KhtkYxFEIvwrCFlE5v1Ofa_krOHI-XXXWPY/edit#gid=0.

[awarzynski]

Address comment from @CarolineConcatto + rebase

[awarzynski]

Rebased on top of main

[awarzynski]

Tidy-up include paths

This was pointed out by @CarolineConcatto offline, thank you!

[CarolineConcatto]

Thank you @awarzynski for implementing fsyntax-only.
It is another feature that the new driver provides, it is nice to see thing falling into place.
The patch looks good to me!

flang/include/flang/Frontend/FrontendActions.h

13

Do you need this library here?

clang/include/clang/Driver/Options.td

def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable optimizations based on the strict definition of an enum's "
            "value range">;
 def fstrict_vtable_pointers: Flag<["-"], "fstrict-vtable-pointers">,
   Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable optimizations based on the strict rules for overwriting "
              "polymorphic C++ objects">;
 def fstrict_overflow : Flag<["-"], "fstrict-overflow">, Group<f_Group>;
 def fsyntax_only : Flag<["-"], "fsyntax-only">,
-  Flags<[NoXarchOption,CoreOption,CC1Option]>, Group<Action_Group>;
+  Flags<[NoXarchOption,CoreOption,CC1Option,FC1Option]>, Group<Action_Group>;
 def ftabstop_EQ : Joined<["-"], "ftabstop=">, Group<f_Group>;
 def ftemplate_depth_EQ : Joined<["-"], "ftemplate-depth=">, Group<f_Group>;
 def ftemplate_depth_ : Joined<["-"], "ftemplate-depth-">, Group<f_Group>;
 def ftemplate_backtrace_limit_EQ : Joined<["-"], "ftemplate-backtrace-limit=">,
                                    Group<f_Group>;
 def foperator_arrow_depth_EQ : Joined<["-"], "foperator-arrow-depth=">,
                                Group<f_Group>;
 

clang/lib/Driver/ToolChains/Flang.cpp

void Flang::ConstructJob(Compilation &C, const JobAction &JA,
   // by `flang-new -fc1`, so we only add it selectively to actions that we
   // don't support/execute just yet.
   if (isa<PreprocessJobAction>(JA)) {
     if (C.getArgs().hasArg(options::OPT_test_io))
       CmdArgs.push_back("-test-io");
     else
       CmdArgs.push_back("-E");
   } else if (isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) {
-    CmdArgs.push_back("-triple");
-    CmdArgs.push_back(Args.MakeArgString(TripleStr));
     if (JA.getType() == types::TY_Nothing) {
       CmdArgs.push_back("-fsyntax-only");
     } else if (JA.getType() == types::TY_AST) {
       CmdArgs.push_back("-emit-ast");
     } else if (JA.getType() == types::TY_LLVM_IR ||
                JA.getType() == types::TY_LTO_IR) {
       CmdArgs.push_back("-emit-llvm");
     } else if (JA.getType() == types::TY_LLVM_BC ||

flang/include/flang/Frontend/CompilerInstance.h

 //===-- CompilerInstance.h - Flang Compiler Instance ------------*- 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_COMPILERINSTANCE_H
 #define LLVM_FLANG_FRONTEND_COMPILERINSTANCE_H
 
 #include "flang/Frontend/CompilerInvocation.h"
 #include "flang/Frontend/FrontendAction.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
+#include "flang/Semantics/semantics.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::frontend {
 
 class CompilerInstance {
 
   /// The options used in this compiler instance.
   std::shared_ptr<CompilerInvocation> invocation_;
 
   /// Flang file  manager.
   std::shared_ptr<Fortran::parser::AllSources> allSources_;
 
   std::shared_ptr<Fortran::parser::AllCookedSources> allCookedSources_;
 
   std::shared_ptr<Fortran::parser::Parsing> parsing_;
 
+  /// The stream for diagnostics from Semaantics
+  llvm::raw_ostream *semaOutputStream_ = &llvm::errs();
+
+  /// The stream for diagnostics from Semantics if owned, otherwise nullptr.
+  std::unique_ptr<llvm::raw_ostream> ownedSemaOutputStream_;
+
   /// The diagnostics engine instance.
   llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_;
 
   /// Holds information about the output file.
   struct OutputFile {
     std::string filename_;
     OutputFile(std::string inputFilename)
         : filename_(std::move(inputFilename)) {}
public:
   /// @name File manager
   /// {
 
   /// Return the current allSources.
   Fortran::parser::AllSources &allSources() const { return *allSources_; }
 
   bool HasAllSources() const { return allSources_ != nullptr; }
 
+  parser::AllCookedSources &allCookedSources() {
+    assert(allCookedSources_ && "Compiler instance has no AllCookedSources!");
+    return *allCookedSources_;
+  };
+
   /// }
   /// @name Parser Operations
   /// {
 
   /// Return parsing to be used by Actions.
   Fortran::parser::Parsing &parsing() const { return *parsing_; }
 
   /// }
+  /// @name Semantic analysis
+  /// {
+
+  /// Replace the current stream for verbose output.
+  void set_semaOutputStream(llvm::raw_ostream &Value);
+
+  /// Replace the current stream for verbose output.
+  void set_semaOutputStream(std::unique_ptr<llvm::raw_ostream> Value);
+
+  /// Get the current stream for verbose output.
+  llvm::raw_ostream &semaOutputStream() { return *semaOutputStream_; }
+
+  /// }
   /// @name High-Level Operations
   /// {
 
   /// Execute the provided action against the compiler's
   /// CompilerInvocation object.
   /// \param act - The action to execute.
   /// \return - True on success.
   bool ExecuteAction(FrontendAction &act);

flang/include/flang/Frontend/FrontendActions.h

 //===- FrontendActions.h -----------------------------------------*- 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_FRONTENDACTIONS_H
 #define LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H
 
 #include "flang/Frontend/FrontendAction.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::frontend {
 
 //===----------------------------------------------------------------------===//
 // Custom Consumer Actions
 //===----------------------------------------------------------------------===//
 
 class InputOutputTestAction : public FrontendAction {
   void ExecuteAction() override;
 };
 
 class PrintPreprocessedAction : public FrontendAction {
   void ExecuteAction() override;
 };
 
+class SyntaxOnlyAction : public FrontendAction {
+  void ExecuteAction() override;
+};
+
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H

flang/include/flang/Frontend/FrontendOptions.h

 //===- FrontendOptions.h ----------------------------------------*- 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_FRONTENDOPTIONS_H
 #define LLVM_FLANG_FRONTEND_FRONTENDOPTIONS_H

 enum ActionKind {
   InvalidAction = 0,
 
   /// -test-io mode
   InputOutputTest,
 
   /// -E mode.
   PrintPreprocessedInput,
-  /// TODO: RunPreprocessor, ParserSyntaxOnly, EmitLLVM, EmitLLVMOnly,
+
+  /// -fsyntax-only
+  ParseSyntaxOnly,
+
+  /// TODO: RunPreprocessor, EmitLLVM, EmitLLVMOnly,
   /// EmitCodeGenOnly, EmitAssembly, (...)
 };
 
 inline const char *GetActionKindName(const ActionKind ak) {
   switch (ak) {
   case InputOutputTest:
     return "InputOutputTest";
   case PrintPreprocessedInput:
     return "PrintPreprocessedInput";
+  case ParseSyntaxOnly:
+    return "ParseSyntaxOnly";
   default:
     return "<unknown ActionKind>";
     // TODO:
     // case RunPreprocessor:
     // case ParserSyntaxOnly:
     // case EmitLLVM:
     // case EmitLLVMOnly:
     // case EmitCodeGenOnly:

flang/lib/Frontend/CMakeLists.txt

 add_flang_library(flangFrontend
   CompilerInstance.cpp
   CompilerInvocation.cpp
   FrontendAction.cpp
   FrontendActions.cpp
   FrontendOptions.cpp
   TextDiagnosticPrinter.cpp
   TextDiagnosticBuffer.cpp
   TextDiagnostic.cpp
 
   DEPENDS
   clangBasic
 
   LINK_LIBS
   FortranParser
+  FortranSemantics
+  FortranCommon
   clangBasic
   clangDriver
 
   LINK_COMPONENTS
   Option
   Support
 )

flang/lib/Frontend/CompilerInstance.cpp

 //===--- CompilerInstance.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/CompilerInstance.h"
 #include "flang/Frontend/CompilerInvocation.h"
 #include "flang/Frontend/TextDiagnosticPrinter.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
+#include "flang/Semantics/semantics.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace Fortran::frontend;
 
CompilerInstance::~CompilerInstance() {
   assert(outputFiles_.empty() && "Still output files in flight?");
 }
 
 void CompilerInstance::set_invocation(
     std::shared_ptr<CompilerInvocation> value) {
   invocation_ = std::move(value);
 }
 
+void CompilerInstance::set_semaOutputStream(raw_ostream &Value) {
+  ownedSemaOutputStream_.release();
+  semaOutputStream_ = &Value;
+}
+
+void CompilerInstance::set_semaOutputStream(
+    std::unique_ptr<raw_ostream> Value) {
+  ownedSemaOutputStream_.swap(Value);
+  semaOutputStream_ = ownedSemaOutputStream_.get();
+}
+
 void CompilerInstance::AddOutputFile(OutputFile &&outFile) {
   outputFiles_.push_back(std::move(outFile));
 }
 
 // Helper method to generate the path of the output file. The following logic
 // applies:
 // 1. If the user specifies the output file via `-o`, then use that (i.e.
 //    the outputFilename parameter).

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 "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/Arg.h"
default: {
       llvm_unreachable("Invalid option in group!");
     }
     case clang::driver::options::OPT_test_io:
       opts.programAction_ = InputOutputTest;
       break;
     case clang::driver::options::OPT_E:
       opts.programAction_ = PrintPreprocessedInput;
       break;
+    case clang::driver::options::OPT_fsyntax_only:
+      opts.programAction_ = ParseSyntaxOnly;
+      break;
 
       // TODO:
       // case clang::driver::options::OPT_emit_obj:
       // case calng::driver::options::OPT_emit_llvm:
       // case clang::driver::options::OPT_emit_llvm_only:
       // case clang::driver::options::OPT_emit_codegen_only:
       // case clang::driver::options::OPT_emit_module:
       // (...)

flang/lib/Frontend/FrontendActions.cpp

 //===--- FrontendActions.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/FrontendActions.h"
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Parser/source.h"
+#include "flang/Semantics/semantics.h"
 
 using namespace Fortran::frontend;
 
 void InputOutputTestAction::ExecuteAction() {
 
   // Get the name of the file from FrontendInputFile current.
   std::string path{GetCurrentFileOrBufferName()};
   std::string buf;
void PrintPreprocessedAction::ExecuteAction() {
   if (auto os{ci.CreateDefaultOutputFile(
           /*Binary=*/true, /*InFile=*/GetCurrentFileOrBufferName())}) {
     (*os) << outForPP.str();
   } else {
     llvm::errs() << "Unable to create the output file\n";
     return;
   }
 }
+
+void SyntaxOnlyAction::ExecuteAction() {
+  CompilerInstance &ci = this->instance();
+
+  // TODO: These should be specifiable by users. For now just use the defaults.
+  common::LanguageFeatureControl features;
+  Fortran::common::IntrinsicTypeDefaultKinds defaultKinds;
+
+  // Parse
+  ci.parsing().Parse(llvm::outs());
+  auto &parseTree{*ci.parsing().parseTree()};
+
+  // Prepare semantincs
+  Fortran::semantics::SemanticsContext semanticsContext{
+      defaultKinds, features, ci.allCookedSources()};
+  semanticsContext.set_moduleDirectory("."s);
+  Fortran::semantics::Semantics semantics{
+      semanticsContext, parseTree, ci.parsing().cooked().AsCharBlock()};
+
+  // Run semantic checks
+  semantics.Perform();
+
+  // Report the diagnostics from the semantic checks
+  semantics.EmitMessages(ci.semaOutputStream());
+}

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

 //===--- ExecuteCompilerInvocation.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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file holds ExecuteCompilerInvocation(). It is split into its own file to
 // minimize the impact of pulling in essentially everything else in Flang.
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/FrontendActions.h"
 #include "clang/Driver/Options.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace Fortran::frontend {
 
 static std::unique_ptr<FrontendAction> CreateFrontendBaseAction(
     CompilerInstance &ci) {
 
   ActionKind ak = ci.frontendOpts().programAction_;
   switch (ak) {
   case InputOutputTest:
     return std::make_unique<InputOutputTestAction>();
     break;
   case PrintPreprocessedInput:
     return std::make_unique<PrintPreprocessedAction>();
     break;
+  case ParseSyntaxOnly:
+    return std::make_unique<SyntaxOnlyAction>();
+    break;
   default:
     break;
     // TODO:
     // case RunPreprocessor:
     // case ParserSyntaxOnly:
     // case EmitLLVM:
     // case EmitLLVMOnly:
     // case EmitCodeGenOnly:

flang/test/Flang-Driver/syntax-only.f90

+! RUN: %flang-new -fc1 -fsyntax-only %s 2>&1 | FileCheck %s
+
+! CHECK: IF statement is not allowed in IF statement
+IF (A > 0.0) IF (B < 0.0) A = LOG (A)
+END

flang/unittests/Frontend/PrintPreprocessedTest.cpp

 //===- unittests/Frontend/PrintPreprocessedTest.cpp  FrontendAction tests--===//
 //
 // 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 "gtest/gtest.h"
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/FrontendOptions.h"
 #include "flang/FrontendTool/Utils.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace Fortran::frontend;
 
TEST(FrontendAction, PrintPreprocessedInput) {
   EXPECT_TRUE(
       llvm::StringRef(outputFileBuffer.data()).startswith("program b\n"));
 
   // 6. Clear the input and the output files. Since we used an output buffer,
   // there are no physical output files to delete.
   llvm::sys::fs::remove(inputFile);
   compInst.ClearOutputFiles(/*EraseFiles=*/true);
 }
+
+TEST(FrontendAction, ParseSyntaxOnly) {
+  std::string inputFile = "test-file.f";
+  std::error_code ec;
+
+  // 1. Create the input file for the file manager
+  // AllSources (which is used to manage files inside every compiler instance),
+  // works with paths. This means that it requires a physical file. Create one.
+  std::unique_ptr<llvm::raw_fd_ostream> os{
+      new llvm::raw_fd_ostream(inputFile, ec, llvm::sys::fs::OF_None)};
+  if (ec)
+    FAIL() << "Fail to create the file need by the test";
+
+  // Populate the input file with the pre-defined input and flush it.
+  *(os) << "! if_stmt.f90:\n"
+        << "IF (A > 0.0) IF (B < 0.0) A = LOG (A)\n"
+        << "END";
+  os.reset();
+
+  // Get the path of the input file
+  llvm::SmallString<64> cwd;
+  if (std::error_code ec = llvm::sys::fs::current_path(cwd))
+    FAIL() << "Failed to obtain the current working directory";
+  std::string testFilePath(cwd.c_str());
+  testFilePath += "/" + inputFile;
+
+  // 2. Prepare the compiler (CompilerInvocation + CompilerInstance)
+  CompilerInstance compInst;
+  compInst.CreateDiagnostics();
+  auto invocation = std::make_shared<CompilerInvocation>();
+  invocation->frontendOpts().programAction_ = ParseSyntaxOnly;
+
+  compInst.set_invocation(std::move(invocation));
+  compInst.frontendOpts().inputs_.push_back(
+      FrontendInputFile(testFilePath, Language::Fortran));
+
+  // 3. Set-up the output stream for the semantic diagnostics.
+  llvm::SmallVector<char, 256> outputDiagBuffer;
+  std::unique_ptr<llvm::raw_pwrite_stream> outputStream(
+      new llvm::raw_svector_ostream(outputDiagBuffer));
+  compInst.set_semaOutputStream(std::move(outputStream));
+
+  // 4. Executre the ParseSyntaxOnly action
+  bool success = ExecuteCompilerInvocation(&compInst);
+
+  // 5. Validate the expected output
+  EXPECT_TRUE(success);
+  EXPECT_TRUE(!outputDiagBuffer.empty());
+  EXPECT_TRUE(
+      llvm::StringRef(outputDiagBuffer.data())
+          .startswith(
+              ":2:14: error: IF statement is not allowed in IF statement\n"));
+
+  // 6. Clear the input files.
+  llvm::sys::fs::remove(inputFile);
+}
 } // namespace