[flang][f18] Replace `-fparse-only` with `-fsyntax-only`

[awarzynski]

Summary

-fsyntax-only is the preferred spelling for -fparse-only implemented
in the new Flang driver in [1]. It is consistent with clang and
gfortran. It was originally proposed and accepted in [2] (this
transition was announced in [3]).

This patch replaces -fparse-only with -fsyntax-only in f18
All affected tests are refactored to use the new spelling.

-fparse-only still works, but is now deprecated and triggers a
warning. It will be phased out gradually.

[1] https://reviews.llvm.org/D92854
[2] https://lists.llvm.org/pipermail/flang-dev/2020-November/000588.html
[3] https://lists.llvm.org/pipermail/flang-dev/2021-February/000646.html

[awarzynski]

Add a warning when using -fparse-only

[awarzynski]

I updated the description to make it clearer that this patch deprecates -fparse-only (this reflects the change in the 2nd diff).

[FarisRehman]

flang/tools/f18/f18.cpp

551

Typo of 'warning' :)

[clementval]

flang/tools/f18/f18.cpp

551

Shouldn't you output warning on llvm::errs() ?

[awarzynski]

Similar change was introduced in https://reviews.llvm.org/D95887

flang/test/Evaluate/test_folding.sh

 src=$1
 [[ ! -f $src ]] && echo "File not found: $src" && exit 1
 shift
 
 temp=$1
 mkdir -p $temp
 shift
 
-CMD="$* -fdebug-dump-symbols -fparse-only"
+CMD="$* -fdebug-dump-symbols -fsyntax-only"
 
 # Check if tests should assume folding is using libpgmath
 if [[ $LIBPGMATH ]]; then
   CMD="$CMD -DTEST_LIBPGMATH"
   echo "Assuming libpgmath support"
 else
   echo "Not assuming libpgmath support"
 fi

flang/test/Flang-Driver/parse-error.f95

 ! RUN: not %flang-new -fc1 -fsyntax-only %s 2>&1 | FileCheck %s --check-prefix=ERROR
-! RUN: not %f18 -parse-only %s 2>&1 | FileCheck %s --check-prefix=ERROR
+! RUN: not %f18 -fsyntax-only %s 2>&1 | FileCheck %s --check-prefix=ERROR
 
 ! REQUIRES: new-flang-driver
 
 ! ERROR: Could not parse {{.*}}parse-error.f95
 
 "This file will not parse"

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

 ! RUN: not %flang-new -fc1 -fsyntax-only %s 2>&1 | FileCheck %s
-! RUN: not %f18 -fparse-only %s 2>&1 | FileCheck %s
+! RUN: not %f18 -fsyntax-only %s 2>&1 | FileCheck %s
 
 ! REQUIRES: new-flang-driver
 
 ! CHECK: IF statement is not allowed in IF statement
 ! CHECK: Semantic errors in {{.*}}syntax-only.f90
 IF (A > 0.0) IF (B < 0.0) A = LOG (A)
 END

flang/test/Frontend/prescanner-diag.f90

 ! Test that the driver correctly reports diagnostics from the prescanner. The contents of the include file are irrelevant here.
 
 ! Test with -E (i.e. PrintPreprocessedAction, stops after prescanning)
 ! RUN: %f18 -E -I %S/Inputs/ %s 2>&1 | FileCheck %s
 ! RUN: %flang-new -E -I %S/Inputs/ %s 2>&1 | FileCheck %s
 ! RUN: %flang-new -fc1 -E -I %S/Inputs/ %s 2>&1 | FileCheck %s
 
 ! Test with -fsyntax-only (i.e. ParseSyntaxOnlyAction, stops after semantic checks)
-! RUN: %f18 -fparse-only -I %S/Inputs/ %s 2>&1 | FileCheck %s
+! RUN: %f18 -fsyntax-only -I %S/Inputs/ %s 2>&1 | FileCheck %s
 ! RUN: %flang-new -fsyntax-only -I %S/Inputs/ %s 2>&1 | FileCheck %s
 ! RUN: %flang-new -fc1 -fsyntax-only -I %S/Inputs/ %s 2>&1 | FileCheck %s
 
 ! CHECK: prescanner-diag.f90:14:20: #include: extra stuff ignored after file name
 #include <empty.h> comment
 ! CHECK: prescanner-diag.f90:16:20: #include: extra stuff ignored after file name
 #include "empty.h" comment
 end

flang/test/Lower/pre-fir-tree01.f90

-! RUN: %f18 -fdebug-pre-fir-tree -fparse-only %s | FileCheck %s
+! RUN: %f18 -fdebug-pre-fir-tree -fsyntax-only %s | FileCheck %s
 
 ! Test structure of the Pre-FIR tree
 
 ! CHECK: Subroutine foo
 subroutine foo()
   ! CHECK: <<DoConstruct>>
   ! CHECK: NonLabelDoStmt
   do i=1,5

flang/test/Lower/pre-fir-tree02.f90

-! RUN: %f18 -fdebug-pre-fir-tree -fparse-only %s | FileCheck %s
+! RUN: %f18 -fdebug-pre-fir-tree -fsyntax-only %s | FileCheck %s
 
 ! Test Pre-FIR Tree captures all the intended nodes from the parse-tree
 ! Coarray and OpenMP related nodes are tested in other files.
 
 ! CHECK: Program test_prog
 program test_prog
   ! Check specification part is not part of the tree.
   interface

flang/test/Lower/pre-fir-tree03.f90

-! RUN: %f18 -fdebug-pre-fir-tree -fparse-only -fopenmp %s | FileCheck %s
+! RUN: %f18 -fdebug-pre-fir-tree -fsyntax-only -fopenmp %s | FileCheck %s
 
 ! Test Pre-FIR Tree captures OpenMP related constructs
 
 ! CHECK: Program test_omp
 program test_omp
   ! CHECK: PrintStmt
   print *, "sequential"
 

flang/test/Lower/pre-fir-tree04.f90

-! RUN: %f18 -fdebug-pre-fir-tree -fparse-only %s | FileCheck %s
+! RUN: %f18 -fdebug-pre-fir-tree -fsyntax-only %s | FileCheck %s
 
 ! Test Pre-FIR Tree captures all the coarray related statements
 
 ! CHECK: Subroutine test_coarray
 Subroutine test_coarray
   use iso_fortran_env, only: team_type, event_type, lock_type
   type(team_type) :: t
   type(event_type) :: done

flang/test/Lower/pre-fir-tree05.f90

-! RUN: %f18 -fdebug-pre-fir-tree -fparse-only -fopenacc %s | FileCheck %s
+! RUN: %f18 -fdebug-pre-fir-tree -fsyntax-only -fopenacc %s | FileCheck %s
 
 ! Test structure of the Pre-FIR tree with OpenACC construct
 
 ! CHECK: Subroutine foo
 subroutine foo()
   ! CHECK-NEXT: <<OpenACCConstruct>>
   ! CHECK-NEXT: <<OpenACCConstruct>>
   !$acc parallel

flang/test/Semantics/call17.f90

-! RUN: %f18 -fparse-only $s 2>&1 | FileCheck %s
+! RUN: %f18 -fsyntax-only $s 2>&1 | FileCheck %s
 
 ! Regression test: don't emit a bogus error about an invalid specification expression
 ! in the declaration of a binding
 
 module m
   type :: t
     integer :: n
    contains

flang/test/Semantics/data05.f90

-!RUN: %f18 -fdebug-dump-symbols -fparse-only %s | FileCheck %s
+!RUN: %f18 -fdebug-dump-symbols -fsyntax-only %s | FileCheck %s
 module m
   interface
     integer function ifunc(n)
       integer, intent(in) :: n
     end function
     real function rfunc(x)
       real, intent(in) :: x
     end function

flang/test/Semantics/data08.f90

-! RUN: %f18 -fdebug-dump-symbols -fparse-only %s 2>&1 | FileCheck %s
+! RUN: %f18 -fdebug-dump-symbols -fsyntax-only %s 2>&1 | FileCheck %s
 ! CHECK: DATA statement value initializes 'jx' of type 'INTEGER(4)' with CHARACTER
 ! CHECK: DATA statement value initializes 'jy' of type 'INTEGER(4)' with CHARACTER
 ! CHECK: DATA statement value initializes 'jz' of type 'INTEGER(4)' with CHARACTER
 ! CHECK: DATA statement value initializes 'kx' of type 'INTEGER(8)' with CHARACTER
 ! CHECK: jx (InDataStmt) size=4 offset=0: ObjectEntity type: INTEGER(4) init:1684234849_4
 ! CHECK: jy (InDataStmt) size=4 offset=4: ObjectEntity type: INTEGER(4) init:543384161_4
 ! CHECK: jz (InDataStmt) size=4 offset=8: ObjectEntity type: INTEGER(4) init:1684234849_4
 ! CHECK: kx (InDataStmt) size=8 offset=16: ObjectEntity type: INTEGER(8) init:7523094288207667809_8
 
 integer :: jx, jy, jz
 integer(8) :: kx
 data jx/4habcd/
 data jy/3habc/
 data jz/5habcde/
 data kx/'abcdefgh'/
 end

flang/test/Semantics/data09.f90

-! RUN: %f18 -fparse-only -fdebug-dump-symbols %s 2>&1 | FileCheck %s
+! RUN: %f18 -fsyntax-only -fdebug-dump-symbols %s 2>&1 | FileCheck %s
 ! CHECK: init:[INTEGER(4)::1065353216_4,1073741824_4,1077936128_4,1082130432_4]
 ! Verify that the closure of EQUIVALENCE'd symbols with any DATA
 ! initialization produces a combined initializer.
 real :: a(2), b(2), c(2)
 equivalence(a(2),b(1)),(b(2),c(1))
 data a(1)/1./,b(1)/2./,c/3.,4./
 common /block/ a
 end

flang/test/Semantics/empty.f90

-! RUN: %f18 -fparse-only %s
+! RUN: %f18 -fsyntax-only %s
 ! RUN: rm -rf %t && mkdir %t
 ! RUN: touch %t/empty.f90
-! RUN: %f18 -fparse-only %t/empty.f90
+! RUN: %f18 -fsyntax-only %t/empty.f90

flang/test/Semantics/final02.f90

-!RUN: %f18 -fparse-only %s 2>&1 | FileCheck %s
+!RUN: %f18 -fsyntax-only %s 2>&1 | FileCheck %s
 module m
   type :: t1
     integer :: n
    contains
     final :: t1f0, t1f1
   end type
   type :: t2
     integer :: n

flang/test/Semantics/getdefinition01.f90

  end subroutine
  recursive pure function f() result(x)
   real, allocatable :: x
   x = 1.0
  end function
 end module
 
 ! RUN and CHECK lines at the bottom as this test is sensitive to line numbers
-! RUN: %f18 -fget-definition 6 17 18 -fparse-only %s | FileCheck --check-prefix=CHECK1 %s
-! RUN: %f18 -fget-definition 7 20 23 -fparse-only %s | FileCheck --check-prefix=CHECK2 %s
-! RUN: %f18 -fget-definition 14 3 4 -fparse-only %s | FileCheck --check-prefix=CHECK3 %s
+! RUN: %f18 -fget-definition 6 17 18 -fsyntax-only %s | FileCheck --check-prefix=CHECK1 %s
+! RUN: %f18 -fget-definition 7 20 23 -fsyntax-only %s | FileCheck --check-prefix=CHECK2 %s
+! RUN: %f18 -fget-definition 14 3 4 -fsyntax-only %s | FileCheck --check-prefix=CHECK3 %s
 ! CHECK1: x:{{.*}}getdefinition01.f90, 5, 21-22
 ! CHECK2: yyy:{{.*}}getdefinition01.f90, 5, 24-27
 ! CHECK3: x:{{.*}}getdefinition01.f90, 13, 24-25
 
-! RUN: not %f18 -fget-definition -fparse-only %s 2>&1 | FileCheck --check-prefix=CHECK-ERROR %s
+! RUN: not %f18 -fget-definition -fsyntax-only %s 2>&1 | FileCheck --check-prefix=CHECK-ERROR %s
 ! CHECK-ERROR: Invalid argument to -fget-definitions

flang/test/Semantics/getdefinition02.f

*  x
        end subroutine
        recursive pure function f() result(x)
         real, allocatable :: x
         x = 1.0
        end function
       end module
 
 ! RUN and CHECK lines here as test is sensitive to line numbers
-! RUN: %f18 -fget-definition 7 9 10 -fparse-only %s 2>&1 | FileCheck --check-prefix=CHECK1 %s
-! RUN: %f18 -fget-definition 8 26 29 -fparse-only %s 2>&1 | FileCheck --check-prefix=CHECK2 %s
-! RUN: %f18 -fget-definition 15 9 10 -fparse-only %s 2>&1 | FileCheck --check-prefix=CHECK3 %s
+! RUN: %f18 -fget-definition 7 9 10 -fsyntax-only %s 2>&1 | FileCheck --check-prefix=CHECK1 %s
+! RUN: %f18 -fget-definition 8 26 29 -fsyntax-only %s 2>&1 | FileCheck --check-prefix=CHECK2 %s
+! RUN: %f18 -fget-definition 15 9 10 -fsyntax-only %s 2>&1 | FileCheck --check-prefix=CHECK3 %s
 ! CHECK1: x:{{.*}}getdefinition02.f, 5, 27-28
 ! CHECK2: yyy:{{.*}}getdefinition02.f, 5, 30-33
 ! CHECK3: x:{{.*}}getdefinition02.f, 14, 30-31

flang/test/Semantics/getdefinition03-a.f90

 ! Tests -fget-definition with INCLUDE
 INCLUDE "Inputs/getdefinition03-b.f90"
 
 program main
  use m3
  integer :: x
  x = f
 end program
 
-! RUN: %f18 -fget-definition 7 6 7 -fparse-only %s | FileCheck --check-prefix=CHECK1 %s
-! RUN: %f18 -fget-definition 7 2 3 -fparse-only %s | FileCheck --check-prefix=CHECK2 %s
+! RUN: %f18 -fget-definition 7 6 7 -fsyntax-only %s | FileCheck --check-prefix=CHECK1 %s
+! RUN: %f18 -fget-definition 7 2 3 -fsyntax-only %s | FileCheck --check-prefix=CHECK2 %s
 ! CHECK1: f:{{.*}}getdefinition03-b.f90, 2, 12-13
 ! CHECK2: x:{{.*}}getdefinition03-a.f90, 6, 13-14

flang/test/Semantics/getdefinition04.f90

 ! Tests -fget-definition with COMMON block with same name as variable.
 program main
   integer :: x
   integer :: y
   common /x/ y
   x = y
 end program
 
-! RUN: %f18 -fget-definition 6 3 4 -fparse-only %s | FileCheck %s
+! RUN: %f18 -fget-definition 6 3 4 -fsyntax-only %s | FileCheck %s
 ! CHECK: x:{{.*}}getdefinition04.f90, 3, 14-15

flang/test/Semantics/getdefinition05.f90

 ! Tests -fget-symbols-sources with BLOCK that contains same variable name as 
 ! another in an outer scope.
 program main
   integer :: x
   integer :: y
   block
     integer :: x
     integer :: y
     x = y
   end block
   x = y
 end program
 
 !! Inner x
-! RUN: %f18 -fget-definition 9 5 6 -fparse-only %s | FileCheck --check-prefix=CHECK1 %s
+! RUN: %f18 -fget-definition 9 5 6 -fsyntax-only %s | FileCheck --check-prefix=CHECK1 %s
 ! CHECK1: x:{{.*}}getdefinition05.f90, 7, 16-17
 !! Outer y
-! RUN: %f18 -fget-definition 11 7 8 -fparse-only %s | FileCheck --check-prefix=CHECK2 %s
+! RUN: %f18 -fget-definition 11 7 8 -fsyntax-only %s | FileCheck --check-prefix=CHECK2 %s
 ! CHECK2: y:{{.*}}getdefinition05.f90, 5, 14-15

flang/test/Semantics/getsymbols01.f90

contains
   end subroutine
  end subroutine
  recursive pure function f() result(x)
   real, allocatable :: x
   x = 1.0
  end function
 end module
 
-! RUN: %f18 -fget-symbols-sources -fparse-only %s 2>&1 | FileCheck %s
+! RUN: %f18 -fget-symbols-sources -fsyntax-only %s 2>&1 | FileCheck %s
 ! CHECK-COUNT-1:f:{{.*}}getsymbols01.f90, 12, 26-27
 ! CHECK-COUNT-1:mm1:{{.*}}getsymbols01.f90, 2, 8-11
 ! CHECK-COUNT-1:s:{{.*}}getsymbols01.f90, 5, 18-19
 ! CHECK-COUNT-1:ss:{{.*}}getsymbols01.f90, 9, 19-21
 ! CHECK-COUNT-1:x:{{.*}}getsymbols01.f90, 5, 21-22
 ! CHECK-COUNT-1:x:{{.*}}getsymbols01.f90, 13, 24-25
 ! CHECK-COUNT-1:y:{{.*}}getsymbols01.f90, 5, 24-25

flang/test/Semantics/getsymbols02.f90

 ! Tests -fget-symbols-sources with modules.
 
 PROGRAM helloworld
     use mm2b
     implicit none
     integer::i
     i = callget5()
 ENDPROGRAM
 
-! RUN: %f18 -fparse-only %S/Inputs/getsymbols02-a.f90
-! RUN: %f18 -fparse-only %S/Inputs/getsymbols02-b.f90
-! RUN: %f18 -fget-symbols-sources -fparse-only %s 2>&1 | FileCheck %s
+! RUN: %f18 -fsyntax-only %S/Inputs/getsymbols02-a.f90
+! RUN: %f18 -fsyntax-only %S/Inputs/getsymbols02-b.f90
+! RUN: %f18 -fget-symbols-sources -fsyntax-only %s 2>&1 | FileCheck %s
 ! CHECK: callget5: .{{[/\\]}}mm2b.mod,
 ! CHECK: get5: .{{[/\\]}}mm2a.mod,

flang/test/Semantics/getsymbols03-a.f90

 ! Tests -fget-symbols with INCLUDE
 INCLUDE "Inputs/getsymbols03-b.f90"
 
 program main
  use mm3
  integer :: x
  x = f
 end program
 
-! RUN: %f18 -fget-symbols-sources -fparse-only %s 2>&1 | FileCheck %s
+! RUN: %f18 -fget-symbols-sources -fsyntax-only %s 2>&1 | FileCheck %s
 ! CHECK:f:{{.*}}getsymbols03-b.f90, 2, 12-13
 ! CHECK:main:{{.*}}getsymbols03-a.f90, 4, 9-13
 ! CHECK:mm3:{{.*}}getsymbols03-a.f90, 5, 6-9
 ! CHECK:x:{{.*}}getsymbols03-a.f90, 6, 13-14

flang/test/Semantics/getsymbols04.f90

 ! Tests -fget-symbols-sources with COMMON.
 program main
   integer :: x
   integer :: y
   common /x/ y
   x = y
 end program
 
-! RUN: %f18 -fget-symbols-sources -fparse-only %s 2>&1 | FileCheck %s
+! RUN: %f18 -fget-symbols-sources -fsyntax-only %s 2>&1 | FileCheck %s
 ! CHECK:x:{{.*}}getsymbols04.f90, 3, 14-15
 ! CHECK:x:{{.*}}getsymbols04.f90, 5, 11-12
 ! CHECK:y:{{.*}}getsymbols04.f90, 4, 14-15

flang/test/Semantics/getsymbols05.f90

 ! Tests -fget-symbols-sources with COMMON.
 program main
   integer :: x
   integer :: y
   block
     integer :: x
     x = y
   end block
   x = y
 end program
 
-! RUN: %f18 -fget-symbols-sources -fparse-only %s 2>&1 | FileCheck %s
+! RUN: %f18 -fget-symbols-sources -fsyntax-only %s 2>&1 | FileCheck %s
 ! CHECK:x:{{.*}}getsymbols05.f90, 3, 14-15
 ! CHECK:x:{{.*}}getsymbols05.f90, 6, 16-17
 ! CHECK:y:{{.*}}getsymbols05.f90, 4, 14-15

flang/test/Semantics/missing_newline.f90

 ! RUN: echo -n "end program" > %t.f90
-! RUN: %f18 -fparse-only %t.f90
+! RUN: %f18 -fsyntax-only %t.f90
 ! RUN: echo -ne "\rend program" > %t.f90
-! RUN: %f18 -fparse-only %t.f90
+! RUN: %f18 -fsyntax-only %t.f90

flang/test/Semantics/mod-file-rewriter.f90

 ! RUN: rm -fr %t && mkdir %t && cd %t
-! RUN: %f18 -fparse-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
-! RUN: %f18 -fparse-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
-! RUN: %f18 -fparse-only -fdebug-module-writer %p/Inputs/mod-file-unchanged.f90 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
-! RUN: %f18 -fparse-only -fdebug-module-writer %p/Inputs/mod-file-changed.f90 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
+! RUN: %f18 -fsyntax-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
+! RUN: %f18 -fsyntax-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
+! RUN: %f18 -fsyntax-only -fdebug-module-writer %p/Inputs/mod-file-unchanged.f90 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
+! RUN: %f18 -fsyntax-only -fdebug-module-writer %p/Inputs/mod-file-changed.f90 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
 
 module m
   real :: x(10)
 end module m
 
 ! CHECK_CHANGED: Processing module {{.*}}.mod: module written
 ! CHECK_UNCHANGED: Processing module {{.*}}.mod: module unchanged, not writing

flang/test/Semantics/modifiable01.f90

-! RUN: not %f18 -fparse-only %s 2>&1 | FileCheck %s
+! RUN: not %f18 -fsyntax-only %s 2>&1 | FileCheck %s
 ! Test WhyNotModifiable() explanations
 
 module prot
   real, protected :: prot
   type :: ptype
     real, pointer :: ptr
     real :: x
   end type

flang/test/Semantics/offsets01.f90

-!RUN: %f18 -fdebug-dump-symbols -fparse-only %s | FileCheck %s
+!RUN: %f18 -fdebug-dump-symbols -fsyntax-only %s | FileCheck %s
 
 ! Size and alignment of intrinsic types
 subroutine s1
   integer(1) :: a_i1  !CHECK: a_i1 size=1 offset=0:
   integer(8) :: b_i8  !CHECK: b_i8 size=8 offset=8:
   real(2)    :: c_r2  !CHECK: c_r2 size=2 offset=16:
   real(2)    :: d_r2  !CHECK: d_r2 size=2 offset=18:
   real(8)    :: e_r8  !CHECK: e_r8 size=8 offset=24:

flang/test/Semantics/offsets02.f90

-!RUN: %f18 -fdebug-dump-symbols -fparse-only %s | FileCheck %s
+!RUN: %f18 -fdebug-dump-symbols -fsyntax-only %s | FileCheck %s
 
 ! Size and alignment of derived types
 
 ! Array of derived type with 64-bit alignment
 subroutine s1
   type t1
     real(8) :: a
     real(4) :: b

flang/test/Semantics/offsets03.f90

-!RUN: %f18 -fdebug-dump-symbols -fparse-only %s | FileCheck %s
+!RUN: %f18 -fdebug-dump-symbols -fsyntax-only %s | FileCheck %s
 
 ! Size and alignment with EQUIVALENCE and COMMON
 
 ! a1 depends on a2 depends on a3
 module ma
   real :: a1(10), a2(10), a3(10)
   equivalence(a1, a2(3)) !CHECK: a1, PUBLIC size=40 offset=20:
   equivalence(a2, a3(4)) !CHECK: a2, PUBLIC size=40 offset=12:

flang/test/Semantics/oldparam01.f90

-! RUN: %f18 -falternative-parameter-statement -fdebug-dump-symbols -fparse-only %s 2>&1 | FileCheck %s
+! RUN: %f18 -falternative-parameter-statement -fdebug-dump-symbols -fsyntax-only %s 2>&1 | FileCheck %s
 
 ! Non-error tests for "old style" PARAMETER statements
 
 type :: t
   integer(kind=4) :: n
 end type
 !CHECK: x1, PARAMETER size=4 offset=0: ObjectEntity type: INTEGER(4) init:1_4
 parameter x1 = 1_4 ! integer scalar

flang/test/Semantics/oldparam02.f90

-! RUN: not %f18 -falternative-parameter-statement -fdebug-dump-symbols -fparse-only %s 2>&1 | FileCheck %s
+! RUN: not %f18 -falternative-parameter-statement -fdebug-dump-symbols -fsyntax-only %s 2>&1 | FileCheck %s
 
 ! Error tests for "old style" PARAMETER statements
 subroutine subr(x1,x2,x3,x4,x5)
   type(*), intent(in) :: x1
   class(*), intent(in) :: x2
   real, intent(in) :: x3(*)
   real, intent(in) :: x4(:)
   character(*), intent(in) :: x5

flang/test/Semantics/oldparam03.f90

-! RUN: not %f18 -fparse-only %s 2>&1 | FileCheck %s
+! RUN: not %f18 -fsyntax-only %s 2>&1 | FileCheck %s
 
 ! Ensure that old-style PARAMETER statements are disabled by default.
 
 !CHECK: error: expected '('
 parameter x = 666
 end

flang/test/Semantics/resolve100.f90

-!RUN: %f18 -fdebug-dump-symbols -fparse-only %s | FileCheck %s
+!RUN: %f18 -fdebug-dump-symbols -fsyntax-only %s | FileCheck %s
 
 program p
   ! CHECK: a size=4 offset=0: ObjectEntity type: LOGICAL(4)
   ! CHECK: b size=4 offset=4: ObjectEntity type: REAL(4)
   logical :: a = .false.
   real :: b = 9.73
   ! CHECK: a: AssocEntity type: REAL(4) expr:b
   ! CHECK: b: AssocEntity type: LOGICAL(4) expr:a
   associate (b => a, a => b)
     print*, a, b
   end associate
   print*, a, b
 end

flang/test/Semantics/rewrite01.f90

-! RUN: %f18 -fparse-only -fdebug-dump-parse-tree %s 2>&1 | FileCheck %s
+! RUN: %f18 -fsyntax-only -fdebug-dump-parse-tree %s 2>&1 | FileCheck %s
 ! Ensure that READ(CVAR) [, item-list] is corrected when CVAR is a
 ! character variable so as to be a formatted read from the default
 ! unit, not an unformatted read from an internal unit (which is not
 ! possible in Fortran).
 character :: cvar
 ! CHECK-NOT: IoUnit -> Variable -> Designator -> DataRef -> Name = 'cvar'
 ! CHECK: Format -> Expr = 'cvar'
 read(cvar)
 end

flang/test/Semantics/test_errors.sh

 #!/usr/bin/env bash
 # Compile a source file and check errors against those listed in the file.
 # Change the compiler by setting the F18 environment variable.
 
-F18_OPTIONS="-fparse-only"
+F18_OPTIONS="-fsyntax-only"
 srcdir=$(dirname $0)
 source $srcdir/common.sh
 [[ ! -f $src ]] && die "File not found: $src"
 
 log=$temp/log
 actual=$temp/actual
 expect=$temp/expect
 diffs=$temp/diffs

flang/test/Semantics/test_modfile.sh

 #!/usr/bin/env bash
 # Compile a source file and compare generated .mod files against expected.
 
 set -e
-F18_OPTIONS="-fdebug-resolve-names -fparse-only"
+F18_OPTIONS="-fdebug-resolve-names -fsyntax-only"
 srcdir=$(dirname $0)
 source $srcdir/common.sh
 
 actual=$temp/actual.mod
 expect=$temp/expect.mod
 actual_files=$temp/actual_files
 prev_files=$temp/prev_files
 diffs=$temp/diffs

flang/test/Semantics/typeinfo01.f90

-!RUN: %f18 -fdebug-dump-symbols -fparse-only %s | FileCheck %s
+!RUN: %f18 -fdebug-dump-symbols -fsyntax-only %s | FileCheck %s
 ! Tests for derived type runtime descriptions
 
 module m01
   type :: t1
     integer :: n
   end type
 !CHECK: .c.t1, SAVE, TARGET: ObjectEntity type: TYPE(component) shape: 0_8:0_8 init:[component::component(name=.n.n,genre=1_1,category=0_1,kind=4_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
 !CHECK: .dt.t1, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t1,sizeinbytes=4_8,parent=NULL(),uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=.c.t1,procptr=NULL(),special=NULL())

flang/tools/f18/f18.cpp

struct DriverOptions {
   std::vector<std::string> searchDirectories; // -I dir
   std::string moduleDirectory{"."s}; // -module dir
   std::string moduleFileSuffix{".mod"}; // -moduleSuffix suff
   bool forcedForm{false}; // -Mfixed or -Mfree appeared
   bool warnOnNonstandardUsage{false}; // -Mstandard
   bool warningsAreErrors{false}; // -Werror
   bool byteswapio{false}; // -byteswapio
   Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
-  bool parseOnly{false};
+  bool syntaxOnly{false};
   bool dumpProvenance{false};
   bool dumpCookedChars{false};
   bool dumpUnparse{false};
   bool dumpUnparseWithSymbols{false};
   bool dumpParseTree{false};
   bool dumpPreFirTree{false};
   bool dumpSymbols{false};
   bool debugNoSemantics{false};
std::string CompileFortran(std::string path, Fortran::parser::Options options,
   if (driver.dumpPreFirTree) {
     if (auto ast{Fortran::lower::createPFT(parseTree, semanticsContext)}) {
       Fortran::lower::dumpPFT(llvm::outs(), *ast);
     } else {
       llvm::errs() << "Pre FIR Tree is NULL.\n";
       exitStatus = EXIT_FAILURE;
     }
   }
-  if (driver.parseOnly) {
+  if (driver.syntaxOnly) {
     return {};
   }
 
   std::string relo{RelocatableName(driver, path)};
 
   llvm::SmallString<32> tmpSourcePath;
   {
     int fd;
while (!args.empty()) {
     } else if (arg == "-fdebug-no-semantics") {
       driver.debugNoSemantics = true;
     } else if (arg == "-funparse") {
       driver.dumpUnparse = true;
     } else if (arg == "-funparse-with-symbols") {
       driver.dumpUnparseWithSymbols = true;
     } else if (arg == "-funparse-typed-exprs-to-f18-fc") {
       driver.unparseTypedExprsToF18_FC = true;
+    } else if (arg == "-fsyntax-only") {
+      driver.syntaxOnly = true;
     } else if (arg == "-fparse-only") {
-      driver.parseOnly = true;
+      driver.syntaxOnly = true;
+      llvm::outs() << "warnning: `-fparse-only` is deprecated and will "
+                      "be removed in the future, use `-fsyntax-only` "
+                      "instead \n";
     } else if (arg == "-c") {
       driver.compileOnly = true;
     } else if (arg == "-o") {
       driver.outputPath = args.front();
       args.pop_front();
     } else if (arg.substr(0, 2) == "-D") {
       auto eq{arg.find('=')};
       if (eq == std::string::npos) {