compiletools 5.2.0__tar.gz → 5.3.1__tar.gz

{compiletools-5.2.0 → compiletools-5.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiletools
-Version: 5.2.0
+Version: 5.3.1
 Summary: Tools to make compiling C/C++ projects easy
 Keywords: c++,make,development
 Author: DrGeoff
@@ -23,7 +23,7 @@ Requires-Dist: rich>=12.0.0
 Requires-Dist: rich-rst>=1.1.7
 Requires-Dist: stringzilla>=3.0.0
 Requires-Dist: bump-my-version>=0.26.0 ; extra == 'dev'
-Requires-Dist: twine>=5.2.0 ; extra == 'dev'
+Requires-Dist: twine>=5.0.0 ; extra == 'dev'
 Requires-Dist: pytest>=7.0.0 ; extra == 'dev'
 Requires-Dist: pytest-xdist>=3.0.0 ; extra == 'dev'
 Requires-Dist: ruff>=0.12.9 ; extra == 'dev'
@@ -47,7 +47,7 @@ C/C++ build tools that requires almost no configuration.
 :Author: drgeoffathome@gmail.com
 :Date:   2016-08-09
 :Copyright: Copyright (C) 2011-2016 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "compiletools"
-version = "5.2.0"
+version = "5.3.1"
 description = "Tools to make compiling C/C++ projects easy"
 readme = "src/compiletools/README.ct-doc.rst"
 requires-python = ">=3.9"
@@ -33,7 +33,7 @@ dependencies = [
 [project.optional-dependencies]
 dev = [
     "bump-my-version>=0.26.0",
-    "twine>=5.2.0",
+    "twine>=5.0.0",
     "pytest>=7.0.0",
     "pytest-xdist>=3.0.0",
     "ruff>=0.12.9",
@@ -83,7 +83,7 @@ include = [
 ]
 
 [tool.bumpversion]
-current_version = "5.2.0"
+current_version = "5.3.1"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-cache-clean.rst

@@ -9,7 +9,7 @@ Remove the current dependency cache
 :Author: drgeoffathome@gmail.com
 :Date:   2018-02-23
 :Copyright: Copyright (C) 2011-2018 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-cache.rst

@@ -9,7 +9,7 @@ Where is the dependency information used by the ct-* applications stored
 :Author: drgeoffathome@gmail.com
 :Date:   2018-02-21
 :Copyright: Copyright (C) 2011-2018 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-cake.rst

@@ -9,7 +9,7 @@ Swiss army knife for building a C/C++ project
 :Author: drgeoffathome@gmail.com
 :Date:   2018-02-06
 :Copyright: Copyright (C) 2011-2016 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-commandline.rst

@@ -9,7 +9,7 @@ This document describes the command line arguments that are common across ct-* p
 :Author: drgeoffathome@gmail.com
 :Date:   2017-07-06
 :Copyright: Copyright (C) 2011-2016 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-config.rst

@@ -9,7 +9,7 @@ Helper tool for examining ct-* configuration
 :Author: drgeoffathome@gmail.com
 :Date:   2016-08-16
 :Copyright: Copyright (C) 2011-2016 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-doc.rst

@@ -12,7 +12,7 @@ C/C++ build tools that requires almost no configuration.
 :Author: drgeoffathome@gmail.com
 :Date:   2016-08-09
 :Copyright: Copyright (C) 2011-2016 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-filelist.rst

@@ -9,7 +9,7 @@ Determine header and source dependencies of a C/C++ file by following headers an
 :Author: drgeoffathome@gmail.com
 :Date:   2017-07-06
 :Copyright: Copyright (C) 2011-2016 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-findtargets.rst

@@ -9,7 +9,7 @@ What
 :Author: drgeoffathome@gmail.com
 :Date:   2018-04-17
 :Copyright: Copyright (C) 2011-2018 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-gitroot.rst

@@ -9,7 +9,7 @@ What directory is the root of the git repository?
 :Author: drgeoffathome@gmail.com
 :Date:   2017-09-28
 :Copyright: Copyright (C) 2011-2016 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-headertree.rst

@@ -9,7 +9,7 @@ Create a tree of header dependencies starting at the given C/C++ file
 :Author: drgeoffathome@gmail.com
 :Date:   2018-07-26
 :Copyright: Copyright (C) 2011-2018 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-jobs.rst

@@ -9,7 +9,7 @@ How many jobs to run concurrently by the ct-* applications.
 :Author: drgeoffathome@gmail.com
 :Date:   2017-04-28
 :Copyright: Copyright (C) 2011-2016 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-list-variants.rst

@@ -9,7 +9,7 @@ Locates available variants for use by the ct-* applications
 :Author: drgeoffathome@gmail.com
 :Date:   2016-08-16
 :Copyright: Copyright (C) 2011-2016 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/README.ct-magicflags.rst

@@ -9,7 +9,7 @@ Show the magic flags / magic comments that a file exports
 :Author: drgeoffathome@gmail.com
 :Date:   2018-02-23
 :Copyright: Copyright (C) 2011-2018 Zomojo Pty Ltd
-:Version: 5.2.0
+:Version: 5.3.1
 :Manual section: 1
 :Manual group: developers
 

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/cake.py

@@ -13,6 +13,7 @@ import compiletools.filelist
 import compiletools.findtargets
 import compiletools.jobs
 import compiletools.wrappedos
+import compiletools.compilation_database
 
 
 
@@ -51,10 +52,10 @@ class Cake(object):
         """ Has to be separate because --auto fiddles with the args """
         # Create shared cache for all file analysis components
         from compiletools.file_analyzer import create_shared_analysis_cache
-        shared_file_analyzer_cache = create_shared_analysis_cache(self.args)
+        self.shared_file_analyzer_cache = create_shared_analysis_cache(self.args)
         
         self.namer = compiletools.namer.Namer(self.args)
-        self.headerdeps = compiletools.headerdeps.create(self.args, file_analyzer_cache=shared_file_analyzer_cache)
+        self.headerdeps = compiletools.headerdeps.create(self.args, file_analyzer_cache=self.shared_file_analyzer_cache)
         self.magicparser = compiletools.magicflags.create(self.args, self.headerdeps)
         self.hunter = compiletools.hunter.Hunter(self.args, self.headerdeps, self.magicparser)
 
@@ -86,6 +87,28 @@ class Cake(object):
 
         compiletools.findtargets.add_arguments(cap)
 
+        compiletools.utils.add_flag_argument(
+            parser=cap,
+            name="compilation-database",
+            dest="compilation_database",
+            default=True,
+            help="Generate compile_commands.json for clang tooling.",
+        )
+        
+        cap.add(
+            "--compilation-database-output",
+            dest="compilation_database_output",
+            default=None,
+            help="Output filename for compilation database (default: <gitroot>/compile_commands.json)"
+        )
+        
+        cap.add(
+            "--compilation-database-relative-paths",
+            dest="compilation_database_relative",
+            action="store_true", 
+            help="Use relative paths instead of absolute paths in compilation database"
+        )
+
         compiletools.utils.add_boolean_argument(
             parser=cap,
             name="preprocess",
@@ -112,6 +135,24 @@ class Cake(object):
         filelist = compiletools.filelist.Filelist(self.args, self.hunter, style="flat")
         filelist.process()
 
+    def _call_compilation_database(self):
+        """Generate compilation database if requested"""
+        if not getattr(self.args, 'compilation_database', True):
+            return
+        if self.args.clean:
+            return  # Don't generate compilation database during clean
+            
+        # Reuse existing objects to avoid duplicating work
+        creator = compiletools.compilation_database.CompilationDatabaseCreator(
+            self.args, 
+            file_analyzer_cache=self.shared_file_analyzer_cache,
+            namer=self.namer,
+            headerdeps=self.headerdeps,
+            magicparser=self.magicparser,
+            hunter=self.hunter
+        )
+        creator.write_compilation_database()
+
     def _copyexes(self):
         # Copy the executables into the "bin" dir (as per cake)
         # Unless the user has changed the bindir (or set --output)
@@ -162,6 +203,10 @@ class Cake(object):
     def _callmakefile(self):
         makefile_creator = compiletools.makefile.MakefileCreator(self.args, self.hunter)
         makefile_creator.create()
+        
+        # Generate compilation database after makefile creation but before build
+        self._call_compilation_database()
+        
         os.makedirs(self.namer.executable_dir(), exist_ok=True)
         cmd = ["make"]
         if self.args.verbose <= 1:

compiletools-5.3.1/src/compiletools/compilation_database.py

@@ -0,0 +1,249 @@
+import json
+import os
+from typing import List, Dict, Any
+from functools import lru_cache
+
+import stringzilla as sz
+import compiletools.utils
+import compiletools.apptools
+import compiletools.headerdeps
+import compiletools.magicflags
+import compiletools.hunter
+import compiletools.namer
+import compiletools.configutils
+import compiletools.wrappedos
+
+
+class CompilationDatabaseCreator:
+    """Creates compile_commands.json files for clang tooling integration"""
+    
+    def __init__(self, args, file_analyzer_cache=None, namer=None, headerdeps=None, magicparser=None, hunter=None):
+        self.args = args
+        
+        # Use provided objects or create new ones
+        self.namer = namer if namer is not None else compiletools.namer.Namer(args)
+        self.headerdeps = headerdeps if headerdeps is not None else compiletools.headerdeps.create(args, file_analyzer_cache=file_analyzer_cache)
+        self.magicparser = magicparser if magicparser is not None else compiletools.magicflags.create(args, self.headerdeps)
+        self.hunter = hunter if hunter is not None else compiletools.hunter.Hunter(args, self.headerdeps, self.magicparser)
+            
+    @staticmethod
+    def add_arguments(cap):
+        """Add command-line arguments for standalone ct-compilation-database"""
+        # Add standard target arguments that define what sources to process
+        compiletools.apptools.add_target_arguments_ex(cap)
+
+        cap.add(
+            "--compilation-database-output",
+            dest="compilation_database_output",
+            default=None,
+            help="Output filename for compilation database (default: <gitroot>/compile_commands.json)"
+        )
+
+        cap.add(
+            "--relative-paths",
+            dest="compilation_database_relative",
+            action="store_true",
+            help="Use relative paths instead of absolute paths"
+        )
+
+    def _get_compiler_command(self, source_file: str) -> List[str]:
+        """Generate compiler command arguments for a source file with StringZilla optimization"""
+        
+        # Determine compiler based on file extension
+        if compiletools.utils.is_cpp_source(source_file):
+            compiler = self.args.CXX
+        else:
+            compiler = self.args.CC
+        
+        # Build arguments list
+        args = [compiler]
+        
+        # Add standard flags
+        if hasattr(self.args, 'CPPFLAGS') and self.args.CPPFLAGS:
+            if isinstance(self.args.CPPFLAGS, list):
+                args.extend(self.args.CPPFLAGS)
+            else:
+                args.extend(compiletools.utils.cached_shlex_split(self.args.CPPFLAGS))
+                
+        if compiletools.utils.is_cpp_source(source_file):
+            if hasattr(self.args, 'CXXFLAGS') and self.args.CXXFLAGS:
+                if isinstance(self.args.CXXFLAGS, list):
+                    args.extend(self.args.CXXFLAGS)
+                else:
+                    args.extend(compiletools.utils.cached_shlex_split(self.args.CXXFLAGS))
+        else:
+            if hasattr(self.args, 'CFLAGS') and self.args.CFLAGS:
+                args.extend(compiletools.utils.cached_shlex_split(self.args.CFLAGS))
+            
+        # Add magic flags for this specific file
+        try:
+            magic_cppflags = self.magicparser.getmagic_cppflags_for_file(source_file)
+            if magic_cppflags:
+                args.extend(compiletools.utils.cached_shlex_split(magic_cppflags))
+                
+            magic_cxxflags = self.magicparser.getmagic_cxxflags_for_file(source_file)
+            if magic_cxxflags:
+                args.extend(compiletools.utils.cached_shlex_split(magic_cxxflags))
+        except AttributeError:
+            # Magic flags methods may not exist
+            pass
+        
+        # Add compile-only flag
+        args.extend(["-c"])
+        
+        # Add the source file
+        if self.args.compilation_database_relative:
+            args.append(os.path.relpath(source_file, os.getcwd()))
+        else:
+            args.append(os.path.realpath(source_file))
+            
+        return args
+
+    def _create_command_object(self, source_file: str) -> Dict[str, Any]:
+        """Create a single command object for the compilation database"""
+        
+        # Directory is always absolute (working directory)
+        directory = os.path.realpath(os.getcwd())
+            
+        # Get file path - relative or absolute based on option
+        if self.args.compilation_database_relative:
+            file_path = os.path.relpath(source_file, os.getcwd())
+        else:
+            file_path = os.path.realpath(source_file)
+            
+        # Generate arguments
+        arguments = self._get_compiler_command(source_file)
+        
+        return {
+            "directory": directory,
+            "file": file_path,
+            "arguments": arguments
+        }
+
+    def create_compilation_database(self) -> List[Dict[str, Any]]:
+        """Create the compilation database as a list of command objects"""
+
+        commands = []
+
+        # Discover all source files using Hunter's project-level discovery
+        try:
+            # Hunt for all source files from command line arguments and dependencies
+            self.hunter.huntsource()
+            source_files = self.hunter.getsources()
+
+            if self.args.verbose >= 6:
+                print(f"CompilationDatabase: Processing {len(source_files)} source files")
+
+        except Exception as e:
+            if self.args.verbose:
+                print(f"Warning: Error during source hunting: {e}")
+            source_files = []
+
+        # Process each source file
+        for source_file in source_files:
+            if os.path.exists(source_file):
+                command_obj = self._create_command_object(source_file)
+                commands.append(command_obj)
+            elif self.args.verbose >= 2:
+                print(f"Warning: Source file does not exist: {source_file}")
+
+        return commands
+
+    def write_compilation_database(self, output_file: str = None):
+        """Write the compilation database to file with incremental update support"""
+        
+        if output_file is None:
+            output_file = self.namer.compilation_database_pathname()
+            
+        # Create the command objects for current files
+        new_commands = self.create_compilation_database()
+        
+        # For incremental updates: read existing database and merge using StringZilla
+        existing_commands = []
+        if os.path.exists(output_file):
+            try:
+                # Use StringZilla memory-mapped file reading
+                file_content = sz.Str(sz.File(output_file))
+                # JSON parsing requires conversion only at the boundary
+                if len(file_content) > 0:
+                    existing_commands = json.loads(file_content.decode('utf-8'))
+                    if self.args.verbose:
+                        print(f"Loaded existing compilation database with StringZilla: {len(existing_commands)} entries")
+                else:
+                    existing_commands = []
+            except Exception as e:
+                if self.args.verbose:
+                    print(f"Warning: Could not read existing compilation database: {e}")
+                existing_commands = []
+
+        
+        # Merge: Keep existing entries for files we're not updating using StringZilla operations
+        merged_commands = []
+        
+        # Use StringZilla for optimal path processing performance
+        # Build set of normalized file paths from new commands
+        new_files_normalized = set()
+        for cmd in new_commands:
+            # Convert to StringZilla for optimal caching, then back to str for set
+            file_sz = sz.Str(cmd["file"])
+            normalized_sz = compiletools.wrappedos.realpath_sz(file_sz)
+            new_files_normalized.add(str(normalized_sz))
+
+        # Process existing commands with StringZilla optimization
+        for existing_cmd in existing_commands:
+            # Convert to StringZilla for consistent processing
+            existing_file_sz = sz.Str(existing_cmd["file"])
+            existing_normalized_sz = compiletools.wrappedos.realpath_sz(existing_file_sz)
+            if str(existing_normalized_sz) not in new_files_normalized:
+                merged_commands.append(existing_cmd)
+        
+        # Add all new/updated entries
+        merged_commands.extend(new_commands)
+        
+        # Write merged JSON file
+        try:
+            # Ensure the output directory exists
+            output_dir = compiletools.wrappedos.dirname(output_file)
+            if output_dir and not compiletools.wrappedos.isdir(output_dir):
+                os.makedirs(output_dir, exist_ok=True)
+
+            # Use StringZilla Str.write_to for faster file writing - no GIL, no copies
+            json_content = json.dumps(merged_commands, indent=2, ensure_ascii=False)
+            sz.Str(json_content).write_to(output_file)
+                
+            if self.args.verbose:
+                print(f"Written compilation database with {len(merged_commands)} entries to {output_file}")
+                print(f"  Updated: {len(new_commands)} entries")
+                print(f"  Preserved: {len(merged_commands) - len(new_commands)} entries")
+                
+        except Exception as e:
+            print(f"Error writing compilation database: {e}")
+            raise
+
+
+def main(argv=None):
+    """Main entry point for ct-compilation-database"""
+    
+    cap = compiletools.apptools.create_parser(
+        "Generate compile_commands.json for clang tooling", argv=argv
+    )
+    
+    # Add compilation database specific arguments
+    CompilationDatabaseCreator.add_arguments(cap)
+    
+    # Add standard compiletools arguments  
+    compiletools.hunter.add_arguments(cap)
+    
+    # Parse arguments
+    args = compiletools.apptools.parseargs(cap, argv)
+    
+    # Create shared cache for all file analysis components
+    from compiletools.file_analyzer import create_shared_analysis_cache
+    shared_file_analyzer_cache = create_shared_analysis_cache(args)
+    
+    # Create and run the compilation database creator
+    creator = CompilationDatabaseCreator(args, file_analyzer_cache=shared_file_analyzer_cache)
+    creator.write_compilation_database()
+    
+    return 0
+

{compiletools-5.2.0 → compiletools-5.3.1}/src/compiletools/hunter.py

@@ -154,6 +154,8 @@ class Hunter(object):
         compiletools.wrappedos.clear_cache()
         compiletools.headerdeps.HeaderDepsBase.clear_cache()
         compiletools.magicflags.MagicFlagsBase.clear_cache()
+        # Clear class-level cache
+        # Hunter._magic_cache.clear()  # This cache doesn't exist
         # Note: Cannot clear instance-level _parse_magic caches from static method
         # Each Hunter instance will retain its own cache until the instance is destroyed
 
@@ -163,6 +165,11 @@ class Hunter(object):
             self._parse_magic.cache_clear()
         if hasattr(self, '_required_files_cached'):
             self._required_files_cached.cache_clear()
+        # Clear project-level source discovery caches
+        if hasattr(self, '_hunted_sources'):
+            del self._hunted_sources
+        if hasattr(self, '_test_sources'):
+            del self._test_sources
 
     @functools.lru_cache(maxsize=None)
     def _parse_magic(self, filename):
@@ -191,3 +198,114 @@ class Hunter(object):
         if self.args.verbose >= 8:
             print("Hunter asking for header dependencies for ", source_filename)
         return self.headerdeps.process(source_filename)
+
+    def huntsource(self):
+        """Discover all source files from command line arguments and their dependencies.
+
+        This method analyzes the files specified in args.filename, args.static,
+        args.dynamic, and args.tests, then expands each to include all source
+        files it depends on. Results are cached for subsequent getsources() calls.
+        """
+        # For simplicity and test reliability, always recompute
+        # This prevents test isolation issues while maintaining functionality
+        if hasattr(self, '_hunted_sources'):
+            del self._hunted_sources
+        if hasattr(self, '_test_sources'):
+            del self._test_sources
+
+        if self.args.verbose >= 5:
+            print("Hunter::huntsource - Discovering all project sources")
+
+        # Get initial sources from command line arguments
+        initial_sources = []
+        if getattr(self.args, 'static', None):
+            initial_sources.extend(self.args.static)
+        if getattr(self.args, 'dynamic', None):
+            initial_sources.extend(self.args.dynamic)
+        if getattr(self.args, 'filename', None):
+            initial_sources.extend(self.args.filename)
+        if getattr(self.args, 'tests', None):
+            initial_sources.extend(self.args.tests)
+
+
+        if not initial_sources:
+            self._hunted_sources = []
+            if self.args.verbose >= 5:
+                print("Hunter::huntsource - No initial sources found")
+            return
+
+        initial_sources = compiletools.utils.ordered_unique(initial_sources)
+        if self.args.verbose >= 6:
+            print(f"Hunter::huntsource - Initial sources: {initial_sources}")
+
+        # Expand each source to include its dependencies
+        all_sources = set()
+        for source in initial_sources:
+            try:
+                realpath_source = compiletools.wrappedos.realpath(source)
+
+                # Skip files that don't exist
+                if not os.path.exists(realpath_source):
+                    if self.args.verbose >= 2:
+                        print(f"Hunter::huntsource - Source file does not exist: {source} -> {realpath_source}")
+                    continue
+
+                required_sources = self.required_source_files(realpath_source)
+                all_sources.update(required_sources)
+
+                if self.args.verbose >= 7:
+                    print(f"Hunter::huntsource - {source} expanded to {len(required_sources)} sources")
+
+            except Exception as e:
+                if self.args.verbose >= 2:
+                    print(f"Warning: Error expanding source {source}: {e}")
+                # Include the original source even if expansion fails, but only if it exists
+                if os.path.exists(source):
+                    all_sources.add(compiletools.wrappedos.realpath(source))
+
+        # Cache the results as sorted absolute paths
+        self._hunted_sources = sorted(all_sources)  # all_sources already contains realpaths
+
+
+        if self.args.verbose >= 5:
+            print(f"Hunter::huntsource - Discovered {len(self._hunted_sources)} total sources")
+
+    def getsources(self):
+        """Get all discovered source files.
+
+        Returns the list of source files discovered by huntsource().
+        Calls huntsource() automatically if not already called.
+
+        Returns:
+            List of absolute paths to all source files
+        """
+        if not hasattr(self, '_hunted_sources'):
+            self.huntsource()
+        return self._hunted_sources
+
+    def gettestsources(self):
+        """Get test source files specifically.
+
+        Returns only the source files that came from args.tests expansion.
+        Calls huntsource() automatically if not already called.
+
+        Returns:
+            List of absolute paths to test source files
+        """
+        if not hasattr(self, '_test_sources'):
+            # Expand only test sources
+            test_sources = set()
+            if getattr(self.args, 'tests', None):
+                for source in self.args.tests:
+                    try:
+                        realpath_source = compiletools.wrappedos.realpath(source)
+                        required_sources = self.required_source_files(realpath_source)
+                        test_sources.update(required_sources)
+                    except Exception as e:
+                        if self.args.verbose >= 2:
+                            print(f"Warning: Error expanding test source {source}: {e}")
+                        test_sources.add(compiletools.wrappedos.realpath(source))
+
+            self._test_sources = sorted(compiletools.wrappedos.realpath(src) for src in test_sources)
+
+        return self._test_sources