compilers/fortran: fix has_multi_*_arguments

The implementation of the link variant was what should have been the
compiler variant, and there was no valid compiler variant, which meant
it was getting C code.

mesonbuild/compilers/fortran.py

@@ -29,7 +29,6 @@ from .mixins.intel import IntelGnuLikeCompiler, IntelVisualStudioLikeCompiler
 from .mixins.clang import ClangCompiler
 from .mixins.elbrus import ElbrusCompiler
 from .mixins.pgi import PGICompiler
-from .. import mlog
 
 from mesonbuild.mesonlib import (
     version_compare, EnvironmentException, MesonException, MachineChoice, LibType
@@ -145,25 +144,11 @@ class FortranCompiler(CLikeCompiler, Compiler):
         code = 'stop; end program'
         return self._find_library_impl(libname, env, extra_dirs, code, libtype)
 
+    def has_multi_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+        return self._has_multi_arguments(args, env, 'stop; end program')
+
     def has_multi_link_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
-        for arg in args[:]:
-            # some compilers, e.g. GCC, don't warn for unsupported warning-disable
-            # flags, so when we are testing a flag like "-Wno-forgotten-towel", also
-            # check the equivalent enable flag too "-Wforgotten-towel"
-            # GCC does error for "-fno-foobar"
-            if arg.startswith('-Wno-'):
-                args.append('-W' + arg[5:])
-            if arg.startswith('-Wl,'):
-                mlog.warning('{} looks like a linker argument, '
-                             'but has_argument and other similar methods only '
-                             'support checking compiler arguments. Using them '
-                             'to check linker arguments are never supported, '
-                             'and results are likely to be wrong regardless of '
-                             'the compiler you are using. has_link_argument or '
-                             'other similar method can be used instead.'
-                             .format(arg))
-        code = 'stop; end program'
-        return self.has_arguments(args, env, code, mode='compile')
+        return self._has_multi_link_arguments(args, env, 'stop; end program')
 
 
 class GnuFortranCompiler(GnuCompiler, FortranCompiler):

mesonbuild/compilers/mixins/clike.py

@@ -1222,7 +1222,7 @@ class CLikeCompiler(Compiler):
                       mode: str) -> T.Tuple[bool, bool]:
         return self.compiles(code, env, extra_args=args, mode=mode)
 
-    def has_multi_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+    def _has_multi_arguments(self, args: T.List[str], env: 'Environment', code: str) -> T.Tuple[bool, bool]:
         new_args = []  # type: T.List[str]
         for arg in args:
             # some compilers, e.g. GCC, don't warn for unsupported warning-disable
@@ -1240,18 +1240,22 @@ class CLikeCompiler(Compiler):
                              'other similar method can be used instead.'
                              .format(arg))
             new_args.append(arg)
-        code = 'extern int i;\nint i;\n'
         return self.has_arguments(new_args, env, code, mode='compile')
 
-    def has_multi_link_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+    def has_multi_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+        return self._has_multi_arguments(args, env, 'extern int i;\nint i;\n')
+
+    def _has_multi_link_arguments(self, args: T.List[str], env: 'Environment', code: str) -> T.Tuple[bool, bool]:
         # First time we check for link flags we need to first check if we have
         # --fatal-warnings, otherwise some linker checks could give some
         # false positive.
         args = self.linker.fatal_warnings() + args
         args = self.linker_to_compiler_args(args)
-        code = 'int main(void) { return 0; }\n'
         return self.has_arguments(args, env, code, mode='link')
 
+    def has_multi_link_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+        return self._has_multi_link_arguments(args, env, 'int main(void) { return 0; }\n')
+
     @staticmethod
     def _concatenate_string_literals(s: str) -> str:
         pattern = re.compile(r'(?P<pre>.*([^\\]")|^")(?P<str1>([^\\"]|\\.)*)"\s+"(?P<str2>([^\\"]|\\.)*)(?P<post>".*)')