Fortran: Implement F2018 IMPORT statements [PR106135]

2025-09-09  Paul Thomas  <pault@gcc.gnu.org>

gcc/fortran
	PR fortran/106135
	* decl.cc (build_sym): Emit an error if a symbol associated by
	an IMPORT, ONLY or IMPORT, all statement is being redeclared.
	(gfc_match_import): Parse and check the F2018 versions of the
	IMPORT statement. For scopes other than and interface body, if
	the symbol cannot be found in the host scope, generate it and
	set it up such that gfc_fixup_sibling_symbols can transfer its
	'imported attribute' if it turnes out to be a not yet parsed
	procedure. Test for violations of C897-8100.
	* gfortran.h : Add 'import_only' to the gfc_symtree structure.
	Add the enum, 'importstate', which is used for values the new
	field 'import_state' in gfc_namespace.
	* parse.cc (gfc_fixup_sibling_symbols): Transfer the attribute
	'imported' to the new symbol.
	* resolve.cc (check_sym_import_status, check_import_status):
	New functions to test symbols and expressions for violations of
	F2018:C8102.
	(resolve_call): Test the 'resolved_sym' against C8102 by a call
	to 'check_sym_import_status'.
	(gfc_resolve_expr): If the expression is OK and an IMPORT
	statement has been registered in the current scope, test C102
	by calling 'check_import_status'.
	(resolve_select_type): Test the declared derived type in TYPE
	IS and CLASS IS statements.

gcc/testsuite/
	PR fortran/106135
	* gfortran.dg/import3.f90: Use -std=f2008 and comment on change
	in error message texts with f2018.
	* gfortran.dg/import12.f90: New test.

2 files changed, 304 insertions, 0 deletions

diff --git a/gcc/testsuite/gfortran.dg/import12.f90 b/gcc/testsuite/gfortran.dg/import12.f90
new file mode 100644
index 0000000..df1aae6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/import12.f90
@@ -0,0 +1,302 @@
+! { dg-do compile }
+!
+! Tests the variants of IMPORT introduced in F2018
+!
+! Contributed by Paul Thomas  <pault@gcc.gnu.org>
+!
+MODULE M
+  import, none          ! { dg-error "F2018: C897 IMPORT statement" }
+  IMPLICIT NONE
+  integer :: z
+end module
+
+MODULE N
+  IMPLICIT NONE
+  integer :: z
+end module
+
+! Taken from gfortran.dg/pr103312.f90. These F2008-style invocations should
+! be accepted.
+module example
+  type, abstract :: foo
+    integer :: i
+  contains
+    procedure(foo_size), deferred :: size
+    procedure(foo_func), deferred :: func
+  end type
+  abstract interface
+    pure integer function foo_size (this)
+      import :: foo
+      class(foo), intent(in) :: this
+    end function
+    function foo_func (this) result (string)
+      import :: foo
+      class(foo) :: this
+      character(this%size()) :: string
+    end function
+  end interface
+end module
+
+block data blk
+  import, all          ! { dg-error "F2018: C897 IMPORT statement" }
+  integer a(2)
+  common /my_common/a
+  data a/1,2/
+end
+
+subroutine extern_sub1
+  import               ! { dg-error "F2018: C897 IMPORT statement" }
+end
+
+subroutine extern_sub2 (arg1, arg2, arg3)
+  implicit none
+  integer :: arg1, arg2, arg3
+  arg1 = int_fcn ()
+contains
+  integer function int_fcn () 
+    import, only : arg2, arg3
+    int_fcn = arg2 * arg3
+  end
+end
+
+program p
+  import, all          ! { dg-error "F2018: C897 IMPORT statement" }
+  implicit none
+  integer :: x, y
+  type :: t
+    integer :: i
+  end type
+  type(t) :: progtype
+  type, extends(t) :: s
+    integer :: j
+  end type
+  class(t), allocatable :: progclass
+contains
+
+! OK because arg is just that and x is declared in scope of sub1.
+  subroutine sub1 (arg)
+    import, none
+    implicit none
+    real :: arg, x
+  end
+
+! IMPORT, ALL must be the only IMPORT statement in the scope.
+  subroutine sub2 (arg)
+    import, none
+    import, all         ! { dg-error "F2018: C8100 IMPORT statement" }
+    implicit none
+    real :: arg, x
+  end
+
+! Error message says it all.
+  subroutine sub3 (arg)
+    import, none
+    implicit none
+    integer :: arg
+    print *, arg
+    x = 1              ! { dg-error "F2018: C8102" }
+  end
+
+! Error messages say it all.
+  subroutine sub4 (arg)
+    import, only : y
+    implicit none
+    integer :: arg
+    print *, arg
+    x = 1              ! { dg-error "F2018: C8102" }
+    y = 2
+    print *, x         ! { dg-error "F2018: C8102" }
+  end
+
+! IMPORT eos and IMPORT, ALL must be unique in the scope.
+  subroutine sub5a (arg)
+    import, all
+    import             ! { dg-error "F2018: C8100" }
+    implicit none
+    real :: arg
+    real :: x          ! { dg-error "F2018: C8102" }
+  end
+
+  subroutine sub5b (arg)
+    import, only : x
+    implicit none
+    real :: arg
+    real :: x          ! { dg-error "F2018: C8102" }
+  end
+
+! Error message says it all.
+  integer function func1 ()
+    import, only : x
+    func1 = x * y      ! { dg-error "F2018: C8102" }
+  end
+
+! Error messages say it all.
+  subroutine sub6 (arg)
+    import, only : func1
+    import, only : func2
+    import, only : foobar                ! { dg-error "has no IMPLICIT type" }
+    implicit none
+    integer :: arg
+    arg = func1 () * func2 () * func3 () ! { dg-error "F2018: C8102" }
+  end
+
+! Error message says it all.
+  integer function func2 ()
+    use N
+    import, none
+    implicit none
+    func2 = y          ! { dg-error "F2018: C8102" }
+  end
+
+! OK
+  integer function func3 ()
+    func3 = 42
+  end
+
+  subroutine sub7 (arg)
+    implicit none
+    integer :: arg
+! OK
+    block
+       import, only : arg, func1, func2, func3
+       arg = func1 () * func2 () * func3 ()
+    end block
+    block
+       arg = func1 ()
+       import, only : arg, func1   ! { dg-error "Unexpected IMPORT statement" }
+    end block
+  end
+
+! Error messages say it all.
+  subroutine sub8 (arg)
+    implicit none
+    integer :: arg
+    block
+       import, only : func1
+       import, only : func2
+       import, only : foobar                ! { dg-error "has no IMPLICIT type" }
+       arg = func1 () * func2 () * func3 () ! { dg-error "F2018: C8102" }
+    end block
+  end
+
+! ASSOCIATE does not have a specification part so IMPORT cannot appear.
+  subroutine sub9 (arg)
+    implicit none
+    integer :: arg
+    associate (f3 => func3 ())              ! { dg-error "F2018: C8102" }
+       import, only : arg, func1            ! { dg-error "Unexpected IMPORT statement" }
+       arg = func1 () * func2 () * f3       ! { dg-error "F2018: C8102" }
+    end associate
+  end
+
+! OK
+  subroutine sub10 (arg)
+    import, only : t
+    implicit none
+    type(t) :: arg, mytype
+    mytype%i = 1
+    arg = mytype
+  end
+
+! TYPE t does not appear in the IMPORT list
+  subroutine sub11 (arg)
+    import, only : progtype
+    implicit none
+    type(t) :: arg
+    progtype%i = 1   ! { dg-error "F2018: C8102" }
+    arg = progtype   ! { dg-error "F2018: C8102" }
+  end
+
+! TYPE t is excluded by IMPORT, NONE
+  subroutine sub12 (arg)
+    import, none
+    implicit none
+    type(t) :: arg, mytype
+    mytype%i = 1     ! { dg-error "F2018: C8102" }
+    arg = mytype     ! { dg-error "F2018: C8102" }
+  end
+
+! TYPE t does not appear in the IMPORT list
+  subroutine sub13 (arg)
+    import, only : progclass
+    implicit none
+    class(t) :: arg
+    type(t) :: ca(2) = [t(1), t(2)]  ! { dg-error "F2018: C8102" }
+    progclass%i = t(1) ! { dg-error "F2018: C8102" }
+    arg = progclass    ! { dg-error "F2018: C8102" }
+    ca = [t(1), t(2)]  ! { dg-error "has no IMPLICIT type|F2018: C8102" }
+    arg = ca(2)        ! Note: The preceeding line catches 'ca' having no implicit type.
+  end
+
+! TYPE t is excluded by IMPORT, NONE
+  subroutine sub14 (arg)
+    import, none
+    implicit none
+    class(t) :: arg
+    class(t), allocatable ::  myclass
+    myclass%i =  t(1)  ! { dg-error "F2018: C8102" }
+    arg%i = myclass%i  ! { dg-error "F2018: C8102" }
+    select type (arg)  ! { dg-error "F2018: C8102" }
+      type is (t)
+        arg%i = arg%i + 1
+      type is (s)
+        arg%j = -1
+    end select
+  end
+
+! TYPE s does not appear in the IMPORT, ONLY list
+  subroutine sub15 (arg)
+    import, only : t
+    implicit none
+    class(t) :: arg
+    class(t), allocatable ::  myclass
+    myclass =  t(1)
+    arg%i = myclass%i
+    select type (arg)  ! { dg-error "F2018: C8102" }
+      type is (t)
+        arg%i = arg%i + 1
+      type is (s)
+        arg%j = -1     ! s is caught at the SELECT TYPE statement
+    end select
+  end
+
+! This is OK
+  subroutine sub16 (arg)
+    import, only : t, s
+    implicit none
+    class(t) :: arg
+    class(t), allocatable ::  myclass
+    myclass =  t(1)
+    arg%i = myclass%i
+    select type (arg)
+      type is (t)
+        arg%i = arg%i + 1
+      type is (s)
+        arg%j = -1
+    end select
+  end
+
+  subroutine sub17 (arg)
+    import, only : t
+    implicit none
+    class(t) :: arg
+    call sub16 (arg)  ! { dg-error "F2018: C8102" }
+  end
+
+! Make sure that recursive procedures do not require the procedure itself to be imported.
+  recursive subroutine sub18 (arg)
+    import, none
+    implicit none
+    integer :: arg
+    if (arg <= 0) call sub18 (arg)
+    arg = 1
+  end
+
+  recursive integer function func4 (arg) result (res)
+    import, none
+    implicit none
+    integer :: arg
+    if (arg <= 0) arg = func4 (arg)
+    res = 1
+  end
+end
diff --git a/gcc/testsuite/gfortran.dg/import3.f90 b/gcc/testsuite/gfortran.dg/import3.f90
index 74cd527..9288c6b 100644
--- a/gcc/testsuite/gfortran.dg/import3.f90
+++ b/gcc/testsuite/gfortran.dg/import3.f90
@@ -1,6 +1,8 @@
 ! { dg-do compile }
+! { dg-options "-std=f2008" }
 ! { dg-shouldfail "Invalid use of IMPORT" }
 ! Test invalid uses of import
+! Wording of some error messages change for -std>=F2018 but all are caught.
 ! PR fortran/29601
 
 subroutine test()