ceedling 1.1.10 → 1.2.0

data/lib/ceedling/partials/partializer.rb

@@ -14,6 +14,7 @@ require 'ceedling/c_extractor/c_extractor'
 require 'ceedling/c_extractor/c_extractor_constants'
 require 'ceedling/c_extractor/c_extractor_types'
 require 'ceedling/constants'
+require 'ceedling/path_mirror'
 require 'ceedling/encodinator'
 
 class Partializer
@@ -24,7 +25,7 @@ class Partializer
 
   include Partials
 
-  constructor :partializer_helper, :file_finder, :c_extractor, :file_path_utils,
+  constructor :configurator, :partializer_helper, :file_finder, :c_extractor, :file_path_utils,
               :preprocessinator_reconstructor, :file_wrapper, :reportinator, :loginator
 
   def setup()
@@ -32,20 +33,31 @@ class Partializer
     @helper = @partializer_helper
   end
 
-  def validate_config(c_module:, config:, name:)
+  def validate_config(c_module:, config:, name:, fallback:)
     msg = @reportinator.generate_progress("Validating Partial config for '#{name}'")
     @loginator.log(msg, Verbosity::DEBUG)
     @helper.validate_function_names_exist(c_module, config, name)
     @helper.validate_no_additions_subtractions_overlap(config, name)
     @helper.validate_additions_subtractions_visibility(c_module, config, name)
+
+    # Fallback preprocessing resolves strictly less than the accurate pass, and two module
+    # shapes are knowably beyond it. Reading the original text happens here, at the I/O edge,
+    # so the check itself stays pure.
+    return unless fallback
+
+    @helper.validate_fallback_sufficiency(
+      name: name,
+      module_name: config.module,
+      files: _module_file_texts(config)
+    )
   end
 
   def sanitize(c_module)
-    # Remove macro definitions that contain the CEEDLING_GENERATED sentinel string.
-    # These are include-guard and boilerplate macros injected into Ceedling-generated header files.
-    removed = c_module.macro_definitions.select { |m| m.text.include?(CEEDLING_GENERATED) }
+    # Remove macro definitions carrying a generated include guard. Ceedling writes these into
+    # the headers it generates, and they belong to those headers, not the module.
+    removed = c_module.macro_definitions.select { |m| m.text.match?(GENERATED_INCLUDE_GUARD_PATTERN) }
     # Remove from both the macro_definitions list and the element_sequence that references it
-    c_module.macro_definitions.reject! { |m| m.text.include?(CEEDLING_GENERATED) }
+    c_module.macro_definitions.reject! { |m| removed.include?(m) }
     c_module.element_sequence.reject!  { |e| removed.include?(e) }
   end
 
@@ -66,29 +78,90 @@ class Partializer
     )
     @loginator.log(msg, Verbosity::DEBUG)
 
+    # Report the first overlap and abort. An `each` here would read as though
+    # every offending function gets reported, which it cannot -- the raise ends
+    # the build on the first one.
     overlap = impl_names & interface_names
-    overlap.each do |func_name|
+    unless overlap.empty?
       raise CeedlingException.new(
-        "#{name}: Partial '#{partial}' ⏩️ Function '#{func_name}' cannot be both testable and mockable"
+        "#{name}: Partial '#{partial}' ⏩️ Function '#{overlap.first}' cannot be both testable and mockable"
       )
     end
   end
 
-  def populate_filepaths(configs)
+  # A Partial module is resolved the way every other file reference in a test is, by
+  # matching trailing path segments. Two things make that correct here.
+  #
+  # `collection` is the ordered header list this one test would search, so a
+  # TEST_INCLUDE_PATH() in that test decides which module it gets. Resolving against
+  # one project-wide collection instead lets two modules sharing a basename collapse
+  # to whichever appears first, no matter which test asked.
+  #
+  # The source is then found by way of the resolved header, so a bare module name
+  # cannot pair one module's header with another module's source.
+  def populate_filepaths(configs, collection: nil, test_filepath: nil)
     configs.each do |_module, config|
       # Every partial involves processing header files
-      config.header.filepath = @file_finder.find_header_file(_module, :ignore)
+      config.header.filepath = @file_finder.find_header_file(_module, :ignore, collection: collection)
+
+      _validate_named_directory_resolved!(_module, config.header.filepath, test_filepath)
 
       # Source file not needed only when mocking public functions exclusively
       unless !config.tests.present? && config.mocks.type == PUBLIC
-        config.source.filepath = @file_finder.find_source_file(_module, :ignore)
+        config.source.filepath = _find_module_source(_module, config.header.filepath)
       end
     end
 
     return configs
   end
 
-  # When `test:` is provided, logs the resulting includes at OBNOXIOUS.
+  # A module named by directory was spelled out by its author, so it is looked up
+  # verbatim with no fallback. A bare name is narrowed by its resolved header's own
+  # directory, which is what keeps one module's header from pairing with another
+  # module's source. The fallback after that serves a project whose source and include
+  # trees do not mirror one another, where a header sits under a directory its source
+  # does not.
+  def _find_module_source(_module, header_filepath)
+    return @file_finder.find_source_file(_module, :ignore) if _names_directory?(_module)
+
+    subdir = header_filepath.nil? ? '' : PathMirror.relative_subdir(header_filepath, _header_roots)
+
+    unless subdir.empty?
+      found = @file_finder.find_source_file(File.join(subdir, _module), :ignore)
+      return found unless found.nil?
+    end
+
+    return @file_finder.find_source_file(_module, :ignore)
+  end
+
+  # Roots a header can sit beneath, which is what its mirrored directory is measured
+  # against. The same three the project-wide header collection is built from.
+  def _header_roots
+    @configurator.paths_test + @configurator.paths_support + @configurator.paths_include
+  end
+
+  # Either separator counts. The qualifier validation already rejects a backslash-rooted
+  # absolute path, so a backslash reaching here is a relative directory like any other.
+  def _names_directory?(_module)
+    _module.match?( %r{[\\/]} )
+  end
+
+  # A bare module name that matches nothing keeps its older behavior, generating a
+  # degenerate Partial. A directory that matches nothing is a typo worth saying so,
+  # since naming the directory was a deliberate act and no older behavior is at stake.
+  def _validate_named_directory_resolved!(_module, header_filepath, test_filepath)
+    return unless _names_directory?(_module)
+    return unless header_filepath.nil?
+
+    location = test_filepath.nil? ? '' : " referenced in #{test_filepath}"
+
+    raise CeedlingException.new(
+      "Partial module '#{_module}'#{location} matches no files. " \
+      "A Partial's directory is matched against the trailing end of a module's path, " \
+      "so check the spelling of both the directory and the module."
+    )
+  end
+
   # Includes for the generated implementation header. This module's own header is replaced by
   # the shared types header at its original list position; every other partialized module's
   # include is dropped.
@@ -163,9 +236,10 @@ class Partializer
   # The include guard macro the module's real header defines, or nil when it has none.
   #
   # Read from the original header rather than from the reconstituted copy or from extracted
-  # macros. The reconstituted copy carries a synthetic guard that #sanitize strips, so neither is
-  # a dependable source. A nil return means the header guards itself some other way --
-  # `#pragma once` -- and offers no macro for a generated file to spoof.
+  # macros. The reconstituted copy carries a synthetic guard that #sanitize strips, and the
+  # fallback preprocessing path deliberately excludes a guard from the macros it recovers, so
+  # neither is a dependable source. A nil return means the header guards itself some other way
+  # -- `#pragma once` -- and offers no macro for a generated file to spoof.
   def extract_module_include_guard(filepath)
     return nil if filepath.nil?
 
@@ -173,17 +247,18 @@ class Partializer
     @preprocessinator_reconstructor.extract_include_guard( text )
   end
 
-  # Extracts and combines C code contents from header and source files
+  # Extracts and combines C code contents from a Partial config's header and source files
   #
   # This method uses CExtractor to parse C files and extract their contents including
   # function definitions, function declarations, and variable declarations. If both
   # header and source files are provided, their contents are merged into a single
   # CModule structure.
   #
-  # @param header_filepath [String, nil] Path to the header file to extract from.
-  #   If nil, no header content is extracted.
-  # @param source_filepath [String, nil] Path to the source file to extract from.
-  #   If nil, no source content is extracted.
+  # @param name [String] The test this extraction is running for (log/error context).
+  # @param config [Partials::ModuleConfig] The Partial's own config, carrying `header`/
+  #   `source` (each a ConfigFileInfo) and `module`, the module name.
+  # @param fallback [Boolean] Passed through to `associate_function_line_numbers` --
+  #   whether to fall back to plain (non-directives-only) line-number association.
   #
   # @return [CExtractorTypes::CModule] A merged CModule containing all extracted contents
   #   from both files. The structure includes:
@@ -193,7 +268,7 @@ class Partializer
   #
   # @note The method always starts with an empty CModule and merges in contents
   #   from any provided files using the CModule's + operator for combining structures.
-  def extract_module_contents(name, config, fallback)
+  def extract_module_contents(name, config, fallback:)
     # Array for CModule structs
     contents = [CExtractorTypes::CModule.new()]
 
@@ -432,6 +507,16 @@ class Partializer
     )
   end
 
+  # The module's own header and source text, keyed by filepath. A declaration-only Partial has
+  # no paired source, which leaves that filepath legitimately nil.
+  def _module_file_texts(config)
+    [config.header, config.source].filter_map do |file_info|
+      next if file_info.nil? || file_info.filepath.nil?
+
+      [file_info.filepath, @file_wrapper.read( file_info.filepath ).clean_encoding]
+    end.to_h
+  end
+
   # One body behind all four public remaps. Each differs only in what replaces this module's
   # own header, what becomes of other partialized modules, and the noun it logs under -- the
   # splice, the sanitize, and the logging are identical in every case.
@@ -542,7 +627,7 @@ class Partializer
 
     replaced = false
     spliced = includes.map do |include|
-      if !replaced && include.filename.ext().downcase() == name.downcase()
+      if !replaced && module_basename( name ) == include.filename.ext().downcase()
         replaced = true
         UserInclude.new(replacement)
       else
@@ -563,12 +648,19 @@ class Partializer
   # Remove includes that match the given module names (case-insensitive)
   # Returns a new array with matching includes removed
   def remove_matching_includes(includes:, modules:)
-    # Normalize module names to lowercase for comparison
-    normalized_modules = modules.map(&:downcase)
-    
+    normalized_modules = modules.map { |_module| module_basename( _module ) }
+
     # Filter out includes (minus extension) that match any module name
     return includes.reject do |include|
       normalized_modules.include?(include.filename.ext().downcase())
     end
-  end  
+  end
+
+  # A module name reduced to what an #include actually carries. An #include names a
+  # file, not a module, so a module named by directory still has to be recognized by
+  # the basename its own header include spells out.
+  def module_basename(_module)
+    File.basename( _module ).ext().downcase()
+  end
+
 end

data/lib/ceedling/partials/partializer_config.rb

@@ -19,6 +19,10 @@ class PartializerConfig
   constructor :c_extractor_preprocessing
 
   # Macro names for all partial configuration macros
+  #
+  # Each macro has a directory-qualified `_AT` counterpart taking a leading directory
+  # parameter. Recognition requires an exact name match followed by an open parenthesis,
+  # so a name and its own `_AT` extension stay distinct however they are ordered here.
   MACRO_NAMES = [
     'TEST_PARTIAL_PUBLIC_MODULE',
     'TEST_PARTIAL_PRIVATE_MODULE',
@@ -30,7 +34,20 @@ class PartializerConfig
     'MOCK_PARTIAL_ALL_MODULE',
     'TEST_PARTIAL_CONFIG',
     'MOCK_PARTIAL_CONFIG',
-  ].freeze
+    'TEST_PARTIAL_PUBLIC_MODULE_AT',
+    'TEST_PARTIAL_PRIVATE_MODULE_AT',
+    'MOCK_PARTIAL_PUBLIC_MODULE_AT',
+    'MOCK_PARTIAL_PRIVATE_MODULE_AT',
+    'TEST_PARTIAL_MODULE_AT',
+    'MOCK_PARTIAL_MODULE_AT',
+    'TEST_PARTIAL_ALL_MODULE_AT',
+    'MOCK_PARTIAL_ALL_MODULE_AT',
+    'TEST_PARTIAL_CONFIG_AT',
+    'MOCK_PARTIAL_CONFIG_AT',
+  ].freeze unless const_defined?(:MACRO_NAMES, false)
+
+  # Suffix marking a macro that takes a leading directory parameter.
+  QUALIFIED_SUFFIX = '_AT' unless const_defined?(:QUALIFIED_SUFFIX, false)
 
   # Holds function-level extraction config for tests or mocks within a Partial.
   # type         -- :public, :private, or :accumulate (additions-driven); nil if unset
@@ -54,7 +71,7 @@ class PartializerConfig
       # DEDUCT: starts with all functions; zero subtractions is valid ("include everything")
       return true
     end
-  end
+  end unless const_defined?(:PartialFunctions, false)
 
   # Top-level Partial configuration for a single C module.
   Config = Struct.new(:module, :tests, :mocks, :header, :source, keyword_init: true) do
@@ -65,7 +82,7 @@ class PartializerConfig
                    source: Partials::ConfigFileInfo.new)
       super
     end
-  end
+  end unless const_defined?(:Config, false)
 
   # Extract partial configuration macros from a string.
   # Returns a hash of module_name => Config.
@@ -95,15 +112,20 @@ class PartializerConfig
       macro_name, params = @c_extractor_preprocessing.parse_macro_call(call_str)
       next if macro_name.nil?
 
-      if macro_name.end_with?('_CONFIG')
+      # A directory-qualified macro behaves exactly as its unqualified counterpart
+      # once its leading directory parameter is folded into the module key, so
+      # dispatch and validation below work from the unqualified name.
+      base_macro = _unqualified_name(macro_name)
+
+      if base_macro.end_with?('_CONFIG')
         config_calls << [macro_name, params]
         next
       end
 
-      mod = _strip_quotes(params[0])
+      mod = _module_key(macro_name, params)
       configs[mod] ||= Config.new(module: mod)
 
-      case macro_name
+      case base_macro
       when 'TEST_PARTIAL_PUBLIC_MODULE'
         _check_type_unset!(configs[mod].tests, mod, macro_name)
         configs[mod].tests.type = PUBLIC
@@ -133,7 +155,7 @@ class PartializerConfig
 
     # --- Pass 2: CONFIG macros ---
     config_calls.each do |macro_name, params|
-      mod = _strip_quotes(params[0])
+      mod = _module_key(macro_name, params)
       unless configs.key?(mod)
         raise CeedlingException.new(
           "#{macro_name} references module '#{mod}' but no corresponding MODULE Partial macro directive for that module was found"
@@ -142,7 +164,7 @@ class PartializerConfig
 
       target = macro_name.start_with?('TEST_') ? configs[mod].tests : configs[mod].mocks
 
-      params[1..].each do |raw|
+      _function_params(macro_name, params).each do |raw|
         name = _strip_quotes(raw)
         if name.start_with?('-')
           target.subtractions << name[1..]
@@ -214,4 +236,115 @@ class PartializerConfig
     str[1..-2]
   end
 
+  # True for a directory-qualified macro, which carries a leading directory parameter.
+  def _qualified?(macro_name)
+    macro_name.end_with?( QUALIFIED_SUFFIX )
+  end
+
+  def _unqualified_name(macro_name)
+    macro_name.delete_suffix( QUALIFIED_SUFFIX )
+  end
+
+  # One module identity, however the module was named. A qualified macro's directory
+  # and module parameters join here, so a module declared by one macro family pairs
+  # with a config macro from either, and two modules sharing a basename stay distinct.
+  def _module_key(macro_name, params)
+    unless _qualified?( macro_name )
+      _validate_module!( params[0], macro_name )
+      return params[0]
+    end
+
+    dir = params[0].nil? ? nil : params[0].strip
+
+    _validate_qualifier!( dir, macro_name )
+    _validate_module!( params[1], macro_name, dir: dir )
+
+    File.join( dir, params[1] )
+  end
+
+  # The module argument names one file's stem and nothing more. The preprocessor emits it
+  # verbatim into the generated filename, so anything Ceedling cannot reproduce in the
+  # filename it actually writes names a file that is never written -- surfacing much later
+  # as a missing include for a filename the author never typed.
+  def _validate_module!(mod, macro_name, dir: nil)
+    if mod.nil? || mod.empty?
+      requires = dir.nil? ? 'a module name' : 'a directory and a module name'
+      example  = dir.nil? ? 'module' : 'path/to/module, module'
+
+      raise CeedlingException.new(
+        "#{macro_name}() requires #{requires}, as in #{macro_name}(#{example})."
+      )
+    end
+
+    if mod.include?('"')
+      raise CeedlingException.new(
+        "#{macro_name}() module '#{mod}' must not be quoted. " \
+        "Write the module name as bare text, as in #{macro_name}(#{dir.nil? ? '' : dir + ', '}module)."
+      )
+    end
+
+    return unless mod.match?( %r{[\\/]} )
+
+    raise CeedlingException.new(
+      "#{macro_name}() module '#{mod}' must not contain a path. " \
+      "A module's directory belongs in its own argument, as in #{_qualified_example( macro_name, mod, dir )}. " \
+      "A path in the module argument lands the Partials prefix on the first directory " \
+      "instead of the filename, naming a file Ceedling never writes."
+    )
+  end
+
+  # The call that replaces one carrying a path in its module argument. Whatever directory
+  # the author wrote folds into the directory argument, leaving the module's own stem.
+  def _qualified_example(macro_name, mod, dir)
+    normalized = mod.tr( '\\', '/' )
+    qualifier  = File.dirname( normalized )
+    qualifier  = dir.nil? ? qualifier : File.join( dir, qualifier )
+
+    return "#{_qualified?( macro_name ) ? macro_name : macro_name + QUALIFIED_SUFFIX}" \
+           "(#{qualifier}, #{File.basename( normalized )})"
+  end
+
+  # Function names follow every leading parameter the macro declares.
+  def _function_params(macro_name, params)
+    _qualified?( macro_name ) ? params[2..] : params[1..]
+  end
+
+  # The preprocessor emits the directory verbatim into the generated #include, so a
+  # spelling Ceedling cannot reproduce as a real relative path names a file that is
+  # never written. Both rejections below are that mismatch, caught where the author
+  # can act on it rather than as a missing include much later.
+  def _validate_qualifier!(dir, macro_name)
+    if dir.nil? || dir.empty?
+      raise CeedlingException.new(
+        "#{macro_name}() requires a directory as its first argument, " \
+        "as in #{macro_name}(path/to/module, module)."
+      )
+    end
+
+    # A Partial is written below its test's own generated directory, while the emitted
+    # #include resolves against the including file. A climbing segment makes those two
+    # different places.
+    if dir.split( %r{[\\/]} ).include?( '..' )
+      raise CeedlingException.new(
+        "#{macro_name}() directory '#{dir}' must not contain '..'. " \
+        "A Partial is generated relative to the project root, so its directory cannot " \
+        "climb above it."
+      )
+    end
+
+    if dir.start_with?('"') || dir.end_with?('"')
+      raise CeedlingException.new(
+        "#{macro_name}() directory '#{dir}' must not be quoted. " \
+        "Write the path as bare text, as in #{macro_name}(path/to/module, module)."
+      )
+    end
+
+    if dir.start_with?('/', '\\') || dir.match?(/\A[A-Za-z]:[\/\\]/)
+      raise CeedlingException.new(
+        "#{macro_name}() directory '#{dir}' must be a relative path, not an absolute path. " \
+        "A Partial is generated relative to the project root."
+      )
+    end
+  end
+
 end

data/lib/ceedling/partials/partializer_helper.rb

@@ -12,9 +12,31 @@ require 'ceedling/partials/partials'
 require 'ceedling/c_extractor/c_extractor_declarations'
 require 'ceedling/c_extractor/c_extractor_constants'
 require 'strscan'
+require 'ceedling/constants'
+require 'ceedling/parsing_parcels'
+require 'ceedling/preprocess/c_preprocessor_conditionals'
 
 class PartializerHelper
 
+  # Content Partials relocates out of a module, so a conditional deciding whether it exists has
+  # to be decided rather than assumed.
+  #
+  # Deliberately narrow: a leading type-definition keyword, which is how a file-scope type
+  # definition opens. It does not reach an aggregate written directly on a variable
+  # (`static struct { int a; } slot;`) nor a declaration behind a storage class. Widening it far
+  # enough to catch those would also match an ordinary local declaration inside a function body,
+  # turning a resolvable module into a refused one -- and telling the two apart needs brace
+  # tracking this check does not do. Under-reaching leaves a shape unrefused; over-reaching
+  # breaks a working build.
+  RELOCATED_CONTENT = /^\s*(?:typedef|struct|union|enum)\b/ unless const_defined?(:RELOCATED_CONTENT, false)
+
+  # Any #include, however its target is spelled. Paired with the two PATTERNS filename forms, it
+  # isolates the computed case: a directive whose target matches neither a quoted nor an angled
+  # filename is naming a macro. PreprocessinatorIncludesHandler draws the same distinction for
+  # the same reason, against its own copy of this pattern.
+  ANY_INCLUDE_DIRECTIVE = /^\s*#\s*include\s+\S/ unless const_defined?(:ANY_INCLUDE_DIRECTIVE, false)
+
+
   include Partials
 
   constructor(
@@ -22,6 +44,7 @@ class PartializerHelper
     :c_extractor,
     :c_extractor_declarations,
     :file_path_utils,
+    :parsing_parcels,
     :loginator
   )
 
@@ -239,6 +262,67 @@ class PartializerHelper
 
     return decls
   end
+  # Refuses a module whose shape fallback preprocessing cannot resolve.
+  #
+  # Fallback never runs a compiler. It scans text and tracks a handful of conditional shapes
+  # against a defines list, so two shapes are knowably beyond it, and generating from either
+  # leaves a compiler or a linker to report something arcane several stages later. Refusing
+  # here -- before anything is written -- trades a confusing failure for a specific one.
+  #
+  # `files` maps a filepath to that file's text, so this method reads nothing itself and a spec
+  # can exercise every branch without a filesystem.
+  def validate_fallback_sufficiency(name:, module_name:, files:)
+    files.each do |filepath, text|
+      # One tracker per file, walked alongside the lines so every line is judged in the
+      # conditional state that actually encloses it.
+      tracker = CPreprocessorConditionals.new( [] )
+
+      @parsing_parcels.code_lines_with_num( text ) do |line, _line_num, end_line_num|
+        tracker.process_directive( line )
+
+        reason = _fallback_blocker( line, tracker )
+        next if reason.nil?
+
+        raise CeedlingException.new(
+          "Partial #{name}::#{module_name} \u23e9\ufe0f #{filepath}:#{end_line_num} #{reason} " \
+          "Partials for this module require directives-only preprocessing."
+        )
+      end
+    end
+  end
+
+  # What puts this line beyond fallback preprocessing, or nil when fallback resolves it.
+  #
+  # Only an active line can matter. A directive or definition that fallback already drops with
+  # the rest of an inactive block is no reason to refuse -- a real preprocessor drops it too.
+  def _fallback_blocker(line, tracker)
+    return nil unless tracker.active?
+
+    # An #include naming a macro needs real expansion to resolve. Fallback has none, so the
+    # include is lost outright and whatever it declared is missing from every list built from it,
+    # the dependencies the shared types header carries included.
+    if _computed_include?( line )
+      'computes an #include target that fallback preprocessing cannot resolve.'
+
+    # Content chosen by a condition the tracker kept without evaluating. Keeping such a block is
+    # the safe default for text the Partial ignores and the wrong answer for content it
+    # relocates: the types header would carry a type the build should not have, and no later
+    # stage can tell it was a guess.
+    elsif tracker.unevaluated? && _relocated_content?( line )
+      'sits behind a conditional expression that fallback preprocessing cannot evaluate.'
+    end
+  end
+
+  def _computed_include?(line)
+    line.match?( ANY_INCLUDE_DIRECTIVE ) &&
+      !line.match?( PATTERNS::USER_INCLUDE_DIRECTIVE_FILENAME ) &&
+      !line.match?( PATTERNS::SYSTEM_INCLUDE_DIRECTIVE_FILENAME )
+  end
+
+  def _relocated_content?(line)
+    line.match?( RELOCATED_CONTENT ) || line.match?( ANY_INCLUDE_DIRECTIVE )
+  end
+
 
   # For each function definition in funcs, find the matching function by name in the fully
   # preprocessed expansion file and replace the three signature-related fields with their
@@ -305,10 +389,12 @@ class PartializerHelper
     mod = config.module
 
     {TEST: config.tests, MOCK: config.mocks}.each do |label, pf|
+      # Report the first overlap and abort, as above -- an `each` would imply
+      # every offending function gets reported.
       overlap = Set.new(pf.additions) & Set.new(pf.subtractions)
-      overlap.each do |func_name|
+      unless overlap.empty?
         raise CeedlingException.new(
-          "#{name}: #{label} Partial configuration for module '#{mod}' ⏩️ Function '#{func_name}' should not be both added and subtracted"
+          "#{name}: #{label} Partial configuration for module '#{mod}' ⏩️ Function '#{overlap.first}' should not be both added and subtracted"
         )
       end
     end

data/lib/ceedling/partials/partializer_utils.rb

@@ -162,7 +162,7 @@ class PartializerUtils
   # @param preprocessed_filepath [String] Path to the preprocessed directives-only file
   # @return [Integer, nil] 1-indexed source line number, or nil if not found
   def locate_function_via_preprocessed(code_block:, filepath:, preprocessed_filepath:)
-    line_num = @code_finder.find_in_preprpocessed_file(preprocessed_filepath, code_block)
+    line_num = @code_finder.find_in_preprocessed_file(preprocessed_filepath, code_block)
     return line_num unless line_num.nil?
 
     msg = "Using fallback C function location search for #{filepath}"

data/lib/ceedling/partials/partials.rb

@@ -22,14 +22,14 @@ module Partials
     def initialize(filepath: nil, directives_only_filepath: nil, full_expansion_filepath: nil, includes: [])
       super
     end
-  end
+  end unless const_defined?(:ConfigFileInfo, false)
 
   # Data class representing a C partial to be generated
   Config = Struct.new(:module, :types, :header, :source, keyword_init: true) do
     def initialize(module:, types: [], header: ConfigFileInfo.new, source: ConfigFileInfo.new)
       super
     end
-  end
+  end unless const_defined?(:Config, false)
 
   # Data class representing a C function signature
   FunctionDeclaration = Struct.new(
@@ -44,7 +44,7 @@ module Partials
     def initialize(name: nil, signature: nil, source_filepath: nil, line_num: nil)
       super
     end
-  end
+  end unless const_defined?(:FunctionDeclaration, false)
 
   # Data class representing a C function with intentionally duplicated fields
   FunctionDefinition = Struct.new(
@@ -59,7 +59,7 @@ module Partials
     def initialize(name: nil, signature: nil, code_block: nil, source_filepath: nil, line_num: nil)
       super
     end
-  end
+  end unless const_defined?(:FunctionDefinition, false)
 
   def self.manufacture_function_declaration(line_num: nil, source_filepath: nil, name:, signature:)
     return FunctionDeclaration.new(