Improve inheritance of profile flags with linkers and wrappers.

source/fab/tools/compiler.py

@@ -74,6 +74,11 @@ def profile_flags(self) -> ProfileFlags:
         ''':returns; the ProfileFlags for this compiler.'''
         return self._profile_flags
 
+    def get_profile_flags(self, profile: str) -> List[str]:
+        ''':returns; the ProfileFlags for the given profile.
+        :param profile: the profile to use.'''
+        return self._profile_flags[profile]
+
     @property
     def mpi(self) -> bool:
         ''':returns: whether this compiler supports MPI or not.'''
@@ -132,7 +137,7 @@ def compile_file(self, input_file: Path,
                     f"instead.")
             params += add_flags
 
-        params.extend(self.profile_flags[config.profile])
+        params.extend(self.get_profile_flags(config.profile))
 
         params.extend([input_file.name,
                       self._output_flag, str(output_file)])

source/fab/tools/compiler_wrapper.py

@@ -120,6 +120,12 @@ def has_syntax_only(self) -> bool:
         raise RuntimeError(f"Compiler '{self._compiler.name}' has "
                            f"no has_syntax_only.")
 
+    def get_profile_flags(self, profile: str) -> List[str]:
+        ''':returns; the ProfileFlags for the given profile, combined
+        from the wrapped compiler and this wrapper.
+        :param profile: the profile to use.'''
+        return self._compiler.get_profile_flags(profile) + self._profile_flags[profile]
+
     def set_module_output_path(self, path: Path):
         '''Sets the output path for modules.
 

source/fab/tools/linker.py

@@ -91,6 +91,16 @@ def output_flag(self) -> str:
         '''
         return self._compiler.output_flag
 
+    def get_profile_flags(self, profile: str) -> List[str]:
+        ''':returns; the ProfileFlags for the given profile, combined
+        from the wrapped compiler and this wrapper.
+        :param profile: the profile to use.'''
+        if self._linker:
+            flags = self._linker.get_profile_flags(profile)[:]
+        else:
+            flags = []
+        return flags + self._compiler.get_profile_flags(profile)
+
     def get_lib_flags(self, lib: str) -> List[str]:
         '''Gets the standard flags for a standard library
 
@@ -201,7 +211,7 @@ def link(self, input_files: List[Path], output_file: Path,
         # TODO: For now we pick up both flags from ProfileFlags and the
         # standard ones from Tool.
         params.extend(self._compiler.flags)
-        params.extend(self._compiler.profile_flags[config.profile])
+        params.extend(self._compiler.get_profile_flags(config.profile))
 
         if config.openmp:
             params.append(self._compiler.openmp_flag)

tests/unit_tests/tools/test_linker.py

@@ -13,7 +13,7 @@
 
 import pytest
 
-from fab.tools import (Category, Linker, ToolRepository)
+from fab.tools import Category, CompilerWrapper, Linker, ToolRepository
 
 
 def test_linker(mock_c_compiler, mock_fortran_compiler):
@@ -369,3 +369,26 @@ def test_linker_inheriting():
     with pytest.raises(RuntimeError) as err:
         linker_mpif90.get_lib_flags("does_not_exist")
     assert "Unknown library name: 'does_not_exist'" in str(err.value)
+
+
+def test_linker_profile_flags_inheriting(mock_c_compiler):
+    '''Test nested compiler and nested linker with inherited profiling flags.
+
+    '''
+    mock_c_compiler_wrapper = CompilerWrapper(name="mock_c_compiler_wrapper",
+                                              compiler=mock_c_compiler,
+                                              exec_name="exec_name")
+    linker = Linker(mock_c_compiler_wrapper)
+    linker_wrapper = Linker(mock_c_compiler_wrapper, linker=linker)
+    count = 0
+    for pf in [mock_c_compiler._profile_flags,
+               mock_c_compiler_wrapper._profile_flags]:
+        pf.define_profile("base")
+        pf.define_profile("derived", "base")
+        pf.add_flags("base", f"-f{count}")
+        pf.add_flags("derived", f"-f{count+1}")
+        count += 2
+
+    # One set f1-f4 from the compiler wrapper, one from the wrapped linker
+    assert (linker_wrapper.get_profile_flags("derived") ==
+            ["-f0", "-f1", "-f2", "-f3", "-f0", "-f1", "-f2", "-f3"])