[Flang] Port test_modfile.sh to Python

[ijan1]

Summary

To enable Flang testing on Windows, shell scripts have
to be ported to Python. The following changes have been made:
"test_modfile.sh" has been ported to Python, and
the relevant tests relying on it.

[Meinersbur]

Is the failure of modfile09.f90 related to D107953?

[ijan1]

In D107956#2941438, @Meinersbur wrote:

Is the failure of modfile09.f90 related to D107953?

No, that's just a mistake on my end that's somehow managed to slip by me. actual_files needs to be declared in advance.

[ijan1]

Fixed modfile09.f90 failing. Updated to use the tempfile library. Using Python-style docstrings now.

[Meinersbur]

Would you like me to look at why "modfile18.f90" and "modfile20.f90" are failing?

flang/test/Semantics/test_modfile.py

82

[ijan1]

In D107956#2947399, @Meinersbur wrote:

Would you like me to look at why "modfile18.f90" and "modfile20.f90" are failing?

That would be brilliant, thank you. "modfile18.f90" is also most likely related to some kind of floating-point number error, same as "modfile20.f90", but no actual cause has been established.

[ijan1]

Would it be fine for me to disable to failing tests for now and have them re-enabled with the fix?

[Meinersbur]

In D107956#2952221, @ijan1 wrote:

Would it be fine for me to disable to failing tests for now and have them re-enabled with the fix?

Yes, I think so. Please add a comment into the test files why they are disabled.

[ijan1]

Updated to disable the 2 failing tests on Windows and also filed a bug report in bugzilla.

[ijan1]

Re-enabling tests on Windows.

[ijan1]

Rebased to mollify buildbots.

[ijan1]

@Meinersbur is this one ready to be merged also?

[Meinersbur]

In D107956#2984755, @ijan1 wrote:

@Meinersbur is this one ready to be merged also?

Yes, LGTM. Please edit the commit message (removes outstanding issues) when committing.

flang/test/Semantics/modfile01.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Check correct modfile generation for type with private component.
 module m
   integer :: i
   integer, private :: j
   type :: t
     integer :: i
     integer, private :: j
   end type

flang/test/Semantics/modfile02.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Check modfile generation for private type in public API.
 
 module m
   type, private :: t1
     integer :: i
   end type
   type, private :: t2
     integer :: i

flang/test/Semantics/modfile03.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Check modfile generation with use-association.
 
 module m1
   integer :: x1
   integer, private :: x2
 end
 !Expect: m1.mod
 !module m1

flang/test/Semantics/modfile04.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! modfile with subprograms
 
 module m1
   type :: t
   end type
 contains
 
   pure subroutine Ss(x, y) bind(c)

flang/test/Semantics/modfile05.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Use-association with VOLATILE or ASYNCHRONOUS
 
 module m1
   real x
   integer y
   volatile z
 contains
 end

flang/test/Semantics/modfile06.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Check modfile generation for external interface
 module m
   interface
     integer function f(x)
     end function
     subroutine s(y, z)
       logical y
       complex z

flang/test/Semantics/modfile07.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Check modfile generation for generic interfaces
 module m1
   interface foo
     real function s1(x,y)
       real, intent(in) :: x
       logical, intent(in) :: y
     end function
     complex function s2(x,y)

flang/test/Semantics/modfile08.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Check modfile generation for external declarations
 module m
   real, external :: a
   logical b
   external c
   complex c
   external b, d
   procedure() :: e

flang/test/Semantics/modfile09.f90

-!RUN: %S/test_modfile.sh '%S/Inputs/modfile09-*' %t %flang_fc1
-!REQUIRES: shell
+!RUN: %python %S/test_modfile.py '%S/Inputs/modfile09-*' %flang_fc1

flang/test/Semantics/modfile10.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Test writing procedure bindings in a derived type.
 
 module m
   interface
     subroutine a(i, j)
       integer :: i, j
     end subroutine
   end interface

flang/test/Semantics/modfile11.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 module m
   type t1(a, b, c)
     integer, kind :: a
     integer(8), len :: b, c
     integer :: d
   end type
   type, extends(t1) :: t2(e)
     integer, len :: e

flang/test/Semantics/modfile12.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 module m
   integer(8), parameter :: a = 1, b = 2_8
   parameter(n=3,l=-3,e=1.0/3.0)
   real :: x(a:2*(a+b*n)-1)
   real, dimension(8) :: y
   type t(c, d)
     integer, kind :: c = 1
     integer, len :: d = a + b

flang/test/Semantics/modfile13.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 module m
   character(2) :: z
   character(len=3) :: y
   character*4 :: x
   character :: w
   character(len=:), allocatable :: v
 contains
   subroutine s(n, a, b, c, d)

flang/test/Semantics/modfile14.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 module m
   type t1
   contains
     procedure, nopass :: s2
     procedure, nopass :: s3
     procedure :: r
     generic :: foo => s2
     generic :: read(formatted)=> r

flang/test/Semantics/modfile15.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 module m
   type :: t
     procedure(a), pointer, pass :: c
     procedure(a), pointer, pass(x) :: d
   contains
     procedure, pass(y) :: a, b
   end type
 contains

flang/test/Semantics/modfile16.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 module m
   character(2), parameter :: prefix = 'c_'
   integer, bind(c, name='c_a') :: a
   procedure(sub), bind(c, name=prefix//'b'), pointer :: b
   type, bind(c) :: t
     real :: c
   end type
   real :: d

flang/test/Semantics/modfile17.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Tests parameterized derived type instantiation with KIND parameters
 
 module m
   type :: capture(k1,k2,k4,k8)
     integer(kind=1), kind :: k1
     integer(kind=2), kind :: k2
     integer(kind=4), kind :: k4
     integer(kind=8), kind :: k8

flang/test/Semantics/modfile18.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Tests folding of array constructors
 
 module m
   real, parameter :: a0 = 1.0_8
   real, parameter :: a1(2) = [real::2.0, 3.0]
   real, parameter :: a2(2) = [4.0, 5.0]
   real, parameter :: a3(0) = [real::]
   real, parameter :: a4(55) = [real::((1.0*k,k=1,j),j=1,10)]

flang/test/Semantics/modfile19.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 module m
   implicit complex(8)(z)
   real :: x
   namelist /nl1/ x, y
   namelist /nl2/ y, x
   namelist /nl1/ i, z
   complex(8) :: z
   real :: y

flang/test/Semantics/modfile20.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Test modfiles for entities with initialization
 module m
   integer, parameter :: k8 = 8
   integer(8), parameter :: k4 = k8/2
   integer, parameter :: k1 = 1
   integer(k8), parameter :: i = 2_k8
   real :: r = 2.0_k4
   character(10, kind=k1) :: c = k1_"asdf"

flang/test/Semantics/modfile21.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 module m
   logical b
   bind(C) :: /cb2/
   common //t
   common /cb/ x(2:10) /cb2/a,b,c
   common /cb/ y,z
   common w
   common u,v

flang/test/Semantics/modfile22.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Test character length conversions in constructors
 
 module m
 type :: t(k)
   integer, kind :: k = 1
   character(kind=k,len=1) :: a
   character(kind=k,len=3) :: b
 end type t

flang/test/Semantics/modfile23.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Test that subprogram interfaces get all of the symbols that they need.
 
 module m1
   integer(8) :: i
   type t1
     sequence
     integer :: j
   end type

flang/test/Semantics/modfile24.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Test declarations with coarray-spec
 
 ! Different ways of declaring the same coarray.
 module m1
   real :: a(1:5)[1:10,1:*]
   real, dimension(5) :: b[1:10,1:*]
   real, codimension[1:10,1:*] :: c(5)
   real, codimension[1:10,1:*], dimension(5) :: d

flang/test/Semantics/modfile25.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Test compile-time analysis of shapes.
 
 module m1
   integer(8), parameter :: a0s(*) = shape(3.14159)
   real :: a1(5,5,5)
   integer(8), parameter :: a1s(*) = shape(a1)
   integer(8), parameter :: a1ss(*) = shape(a1s)
   integer(8), parameter :: a1sss(*) = shape(a1ss)

flang/test/Semantics/modfile26.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Intrinsics SELECTED_INT_KIND, SELECTED_REAL_KIND, PRECISION, RANGE,
 ! RADIX, DIGITS
 
 module m1
   ! INTEGER(KIND=1)  handles  0 <= P < 3
   ! INTEGER(KIND=2)  handles  3 <= P < 5
   ! INTEGER(KIND=4)  handles  5 <= P < 10
   ! INTEGER(KIND=8)  handles 10 <= P < 19

flang/test/Semantics/modfile27.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Test folding of combined array references and structure component
 ! references.
 
 module m1
   type :: t1
     integer :: ia1(2)
   end type t1
   type(t1), parameter :: t1x1(*) = [t1::t1(ia1=[1,2]),t1(ia1=[3,4])]

flang/test/Semantics/modfile28.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 
 ! Test UTF-8 support in character literals
 ! Note: Module files are encoded in UTF-8.
 
 module m
 character(kind=4,len=*), parameter :: c4 = 4_"Hi! 你好!"
 ! In CHARACTER(1) literals, codepoints > 0xff are serialized into UTF-8;
 ! each of those bytes then gets encoded into UTF-8 for the module file.

flang/test/Semantics/modfile29.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Check that implicitly typed entities get a type in the module file.
 
 module m
   public :: a
   private :: b
   protected :: i
   allocatable :: j
 end
 
 !Expect: m.mod
 !module m
 ! real(4)::a
 ! real(4),private::b
 ! integer(4),protected::i
 ! integer(4),allocatable::j
 !end

flang/test/Semantics/modfile30.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Verify miscellaneous bugs
 
 ! The function result must be declared after the dummy arguments
 module m1
 contains
   function f1(x) result(y)
     integer :: x(:)
     integer :: y(size(x))

flang/test/Semantics/modfile31.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Test 7.6 enum values
 
 module m1
   integer, parameter :: x(1) = [4]
   enum, bind(C)
     enumerator :: red, green
     enumerator blue
     enumerator yellow

flang/test/Semantics/modfile32.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Resolution of generic names in expressions.
 ! Test by using generic function in a specification expression that needs
 ! to be written to a .mod file.
 
 ! Resolve based on number of arguments
 module m1
   interface f
     pure integer(8) function f1(x)

flang/test/Semantics/modfile33.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1 -flogical-abbreviations -fxor-operator
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1 -flogical-abbreviations -fxor-operator
 
 ! Resolution of user-defined operators in expressions.
 ! Test by using generic function in a specification expression that needs
 ! to be written to a .mod file.
 
 ! Numeric operators
 module m1
   type :: t

flang/test/Semantics/modfile34.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Test resolution of type-bound generics.
 
 module m1
   type :: t
   contains
     procedure, pass(x) :: add1 => add
     procedure, nopass :: add2 => add
     procedure :: add_real

flang/test/Semantics/modfile35.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 module m1
   type :: t1
   contains
     procedure, pass(x) :: p1 => f
     procedure, non_overridable :: p2 => f
     procedure, nopass :: p3 => f
     generic :: operator(+) => p1
     generic :: operator(-) => p2

flang/test/Semantics/modfile36.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 
 ! Check modfile that contains import of use-assocation of another use-association.
 
 module m1
   interface
      subroutine s(x)
        use, intrinsic :: iso_c_binding, only: c_ptr
        type(c_ptr) :: x

flang/test/Semantics/modfile37.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 
 ! Ensure that a dummy procedure's interface's imports
 ! appear in the module file.
 
 module m
   type :: t
   end type
  contains

flang/test/Semantics/modfile38.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 
 ! Ensure that an interface with the same name as a derived type
 ! does not cause that shadowed name to be emitted later than its
 ! uses in the module file.
 
 module m
   type :: t
   end type

flang/test/Semantics/modfile39.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Resolution of specification expression references to generic interfaces
 ! that resolve to private specific functions.
 
 module m1
   interface gen
     module procedure priv
   end interface
   private :: priv

flang/test/Semantics/modfile40.f90

-! RUN: %S/test_modfile.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Ensure that intrinsics in module files retain their 'private' attribute,
 ! if they are private.
 
 module m1
   intrinsic :: selected_real_kind
   public :: selected_real_kind
 end module
 !Expect: m1.mod

flang/test/Semantics/test_modfile.py

+#!/usr/bin/env python3
+
+"""Compiles a source file and compares generated .mod files against expected.
+
+Parameters:
+    sys.argv[1]: a source file with contains the input and expected output
+    sys.argv[2]: the Flang frontend driver
+    sys.argv[3:]: Optional arguments to the Flang frontend driver"""
+
+import sys
+import re
+import os
+import tempfile
+import subprocess
+import glob
+import common as cm
+
+from pathlib import Path
+from difflib import unified_diff
+
+cm.check_args_long(sys.argv)
+srcdir = Path(sys.argv[1])
+sources = list(glob.iglob(str(srcdir)))
+sources = sorted(sources)
+diffs = ""
+
+flang_fc1 = cm.set_executable(sys.argv[2])
+flang_fc_args = sys.argv[3:]
+flang_fc1_options = "-fsyntax-only"
+
+with tempfile.TemporaryDirectory() as tmpdir:
+    for src in sources:
+        src = Path(src).resolve()
+        actual = ""
+        expect = ""
+        expected_files = set()
+        actual_files = set()
+
+        if not src.is_file():
+            cm.die(src)
+
+        prev_files = set(os.listdir(tmpdir))
+        cmd = [flang_fc1, *flang_fc_args, flang_fc1_options, str(src)]
+        proc = subprocess.check_output(cmd, stderr=subprocess.PIPE,
+                                       universal_newlines=True, cwd=tmpdir)
+        actual_files = set(os.listdir(tmpdir)).difference(prev_files)
+
+        # The first 3 bytes of the files are an UTF-8 BOM
+        with open(src, 'r', encoding="utf-8", errors="strict") as f:
+            for line in f:
+                m = re.search(r"^!Expect: (.*)", line)
+                if m:
+                    expected_files.add(m.group(1))
+
+        extra_files = actual_files.difference(expected_files)
+        if extra_files:
+            print(f"Unexpected .mod files produced: {extra_files}")
+            sys.exit(1)
+
+        for mod in expected_files:
+            mod = Path(tmpdir).joinpath(mod)
+            if not mod.is_file():
+                print(f"Compilation did not produce expected mod file: {mod}")
+                sys.exit(1)
+            with open(mod, 'r', encoding="utf-8", errors="strict") as f:
+                for line in f:
+                    if "!mod$" in line:
+                        continue
+                    actual += line
+
+            with open(src, 'r', encoding="utf-8", errors="strict") as f:
+                for line in f:
+                    if f"!Expect: {mod.name}" in line:
+                        for line in f:
+                            if re.match(r"^$", line):
+                                break
+                            m = re.sub(r"^!", "", line.lstrip())
+                            expect += m
+
+            diffs = "\n".join(unified_diff(actual.replace(" ", "").split("\n"),
+                                           expect.replace(" ", "").split("\n"),
+                                           fromfile=f"{mod.name}", tofile="Expect", n=999999))
+
+            if diffs != "":
+                print(diffs)
+                print()
+                print("FAIL")
+                sys.exit(1)
+
+print()
+print("PASS")
+

flang/test/Semantics/test_modfile.sh

-#!/usr/bin/env bash
-# Compile a source file and compare generated .mod files against expected.
-
-set -e
-FLANG_FC1_OPTIONS="-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
-
-set $src
-
-touch $actual
-for src in "$@"; do
-  [[ ! -f $src ]] && echo "File not found: $src" && exit 1
-  path=$(git ls-files --full-name $src 2>/dev/null || echo $src)
-  (
-    cd $temp
-    ls -1 *.mod > prev_files
-    $FLANG_FC1 $FLANG_FC1_OPTIONS $src
-    ls -1 *.mod | comm -13 prev_files -
-  ) > $actual_files
-  expected_files=$(sed -n 's/^!Expect: \(.*\)/\1/p' $src | sort)
-  extra_files=$(echo "$expected_files" | comm -23 $actual_files -)
-  if [[ ! -z "$extra_files" ]]; then
-    echo "Unexpected .mod files produced:" $extra_files
-    die FAIL $path
-  fi
-  for mod in $expected_files; do
-    if [[ ! -f $temp/$mod ]]; then
-      echo "Compilation did not produce expected mod file: $mod"
-      die FAIL $path
-    fi
-    # The first three bytes of the file are a UTF-8 BOM
-    sed '/^[^!]*!mod\$/d' $temp/$mod > $actual
-    sed '1,/^!Expect: '"$mod"'/d' $src | sed -e '/^$/,$d' -e 's/^!//' > $expect
-    if ! diff -w -U999999 $expect $actual > $diffs; then
-      echo "Module file $mod differs from expected:"
-      sed '1,2d' $diffs
-      die FAIL $path
-    fi
-  done
-  rm -f $actual $expect
-done
-echo PASS