s/patchoptions/instrumentationoptions/g to make a little more logical space to have both patches and contracts

Author: kaoudis

include/patchestry/Passes/InstrumentationPass.hpp

@@ -34,7 +34,7 @@ namespace mlir {
 
 namespace patchestry::passes { // NOLINT
 
-    struct PatchOptions;
+    struct InstrumentationOptions;
 
     /**
      * @brief Registers instrumentation passes with the MLIR pass registry.
@@ -45,7 +45,7 @@ namespace patchestry::passes { // NOLINT
      * instrumentation rules.
      *
      * @param configuration_file Path to the YAML Patchestry configuration file containing 
-     * instrumentation rules
+     * instrumentation rules for applying patches, contracts, or both
      */
     void registerInstrumentationPasses(std::string configuration_file);
 
@@ -56,18 +56,18 @@ namespace patchestry::passes { // NOLINT
      * instance.
      *
      * @param configuration_file Path to the YAML configuration file
-     * @param patch_options Configuration options for controlling function inlining behavior
+     * @param options Configuration options for controlling how instrumentation is generally applied
      * @return std::unique_ptr<mlir::Pass> A unique pointer to the created InstrumentationPass
      */
     std::unique_ptr< mlir::Pass >
-    createInstrumentationPass(const std::string &configuration_file, const PatchOptions &patch_options);
+    createInstrumentationPass(const std::string &configuration_file, const InstrumentationOptions &options);
 
     /**
-     * @brief Configuration options for controlling patching behavior.
+     * @brief Configuration options for controlling instrumentation behavior.
      */
-    struct PatchOptions
+    struct InstrumentationOptions
     {
-        /** @brief Flag to enable or disable function inlining of patch functions */
+        /** @brief Flag to enable or disable function inlining of instrumentation functions */
         bool enable_inlining;
     };
 
@@ -81,9 +81,9 @@ namespace patchestry::passes { // NOLINT
      * @brief MLIR pass that applies code instrumentation based on configuration.
      *
      * The InstrumentationPass is an MLIR transformation pass that modifies MLIR modules
-     * by applying patches according to specifications defined in a YAML configuration file.
-     * It can instrument function calls and operations by inserting patch code before, after,
-     * or replacing the original operations entirely.
+     * by instrumenting according to specifications defined in a YAML configuration file.
+     * It can instrument function calls and operations by inserting patch or contract code
+     * before or after, or by replacing an original operation entirely with a patch.
      *
      * The pass supports three main instrumentation modes:
      * - APPLY_BEFORE: Insert patch code before the matched operation
@@ -100,28 +100,28 @@ namespace patchestry::passes { // NOLINT
         /** @brief Path to the YAML Patchestry configuration file */
         std::string configuration_file;
 
-        /** @brief Parsed patch configuration from the file */
+        /** @brief Parsed patch- or contract-specific configuration from the file */
         std::optional< Configuration > config;
 
         /** @brief List of operations to be inlined after instrumentation */
         std::vector< mlir::Operation * > inline_worklists;
 
         /** @brief Reference to inlining configuration options */
-        const PatchOptions &patch_options;
+        const InstrumentationOptions &options;
 
       public:
         /**
          * @brief Constructs an InstrumentationPass with the given configuration file and
          * options.
          *
-         * The constructor loads and parses the configuration YAML file, validates patch files,
-         * and prepares the pass for execution. If a file cannot be loaded or
-         * parsed, appropriate error messages are logged.
+         * The constructor loads and parses the configuration YAML file, validates the indicated
+         * patches and/or contracts, and prepares the pass for execution. If a file cannot be 
+         * loaded or parsed, appropriate error messages are logged.
          *
          * @param configuration_file Path to the YAML configuration file
          * @param inline_options Reference to inlining configuration options
          */
-        explicit InstrumentationPass(std::string configuration_file, const PatchOptions &patch_options);
+        explicit InstrumentationPass(std::string configuration_file, const InstrumentationOptions &options);
 
         /**
          * @brief Main entry point for the pass execution.

lib/patchestry/Passes/InstrumentationPass.cpp

@@ -265,12 +265,12 @@ namespace patchestry::passes {
      * configuration_file, and use the given inline options for controlling inlining behavior.
      *
      * @param configuration_file Path to the YAML patch specification file
-     * @param inline_options Configuration options for controlling function inlining behavior
+     * @param ∂options Configuration options for controlling how instrumentation is generally applied
      * @return std::unique_ptr<mlir::Pass> A unique pointer to the created InstrumentationPass
      */
     std::unique_ptr< mlir::Pass >
-    createInstrumentationPass(const std::string &configuration_file, const PatchOptions &patch_options) {
-        return std::make_unique< InstrumentationPass >(configuration_file, patch_options);
+    createInstrumentationPass(const std::string &configuration_file, const InstrumentationOptions &options) {
+        return std::make_unique< InstrumentationPass >(configuration_file, options);
     }
 
     template< typename T >
@@ -311,20 +311,20 @@ namespace patchestry::passes {
      * @param patch_options Reference to inlining configuration options
      */
     InstrumentationPass::InstrumentationPass(
-        std::string spec_, const PatchOptions &patch_options_
+        std::string spec_, const InstrumentationOptions &options_
     )
-        : configuration_file(std::move(spec_)), patch_options(patch_options_) {
+        : configuration_file(std::move(spec_)), options(options_) {
         patchestry::yaml::YAMLParser parser;
         ConfigurationFile::getInstance().set_file_path(configuration_file);
         if (!parser.validate_yaml_file< patchestry::passes::Configuration >(configuration_file)) {
-            LOG(ERROR) << "Error: Failed to parse patch specification file: " << configuration_file
+            LOG(ERROR) << "Error: Failed to parse Patchestry configuration file: " << configuration_file
                        << "\n";
             return;
         }
 
         auto buffer_or_err = llvm::MemoryBuffer::getFile(configuration_file);
         if (!buffer_or_err) {
-            LOG(ERROR) << "Error: Failed to read patch specification file: " << configuration_file
+            LOG(ERROR) << "Error: Failed to read Patchestry configuration file: " << configuration_file
                        << "\n";
             return;
         }
@@ -333,7 +333,7 @@ namespace patchestry::passes {
             llvm::sys::path::filename(configuration_file).str()
         );
         if (!config_or_err) {
-            LOG(ERROR) << "Error: Failed to parse patch specification file: " << configuration_file 
+            LOG(ERROR) << "Error: Failed to parse Patchestry configuration file: " << configuration_file 
                        << "\n";
             return;
         }
@@ -355,7 +355,7 @@ namespace patchestry::passes {
                 continue;
             }
         }
-        (void) patch_options;
+        (void) options;
     }
 
     /**
@@ -373,7 +373,7 @@ namespace patchestry::passes {
 
         // check if the configuration is loaded; if not, return
         if (!config) {
-            LOG(ERROR) << "No patch configuration loaded. Skipping instrumentation.\n";
+            LOG(ERROR) << "No Patchestry configuration loaded. Skipping instrumentation.\n";
             return;
         }
 
@@ -867,7 +867,7 @@ namespace patchestry::passes {
      */
     void InstrumentationPass::apply_before_patch(
         mlir::Operation *target_op, const PatchInformation &patch, mlir::ModuleOp patch_module,
-        bool inline_patches
+        bool should_inline
     ) {
         if (target_op == nullptr) {
             LOG(ERROR) << "Patch before: Operation is null";
@@ -923,7 +923,7 @@ namespace patchestry::passes {
         // Set appropriate attributes based on operation type
         set_patch_call_attributes(patch_call_op, target_op);
 
-        if (inline_patches) {
+        if (should_inline) {
             inline_worklists.push_back(patch_call_op);
         }
     }

tools/patchir-transform/main.cpp

@@ -78,7 +78,7 @@ namespace patchestry::instrumentation {
         }
 
         if (enable_instrumentation.getValue()) {
-            patchestry::passes::PatchOptions inline_options = { enable_inlining.getValue() };
+            patchestry::passes::InstrumentationOptions inline_options = { enable_inlining.getValue() };
             mlir::PassManager pm(&context);
             pm.addPass(patchestry::passes::createInstrumentationPass(
                 spec_filename.getValue(), inline_options