On Thu, Apr 26, 2018 at 5:54 PM, Ben Peart [off-list ref] wrote:

On 4/26/2018 6:52 PM, Elijah Newren wrote:

quoted

On Thu, Apr 26, 2018 at 1:52 PM, Ben Peart [off-list ref]
wrote:

quoted

diff --git a/merge-recursive.h b/merge-recursive.h
index 80d69d1401..0c5f7eff98 100644
--- a/merge-recursive.h
+++ b/merge-recursive.h

@@ -17,7 +17,8 @@ struct merge_options {
         unsigned renormalize : 1;
         long xdl_opts;
         int verbosity;
-       int detect_rename;
+       int diff_detect_rename;
+       int merge_detect_rename;
         int diff_rename_limit;
         int merge_rename_limit;
         int rename_score;

@@ -28,6 +29,11 @@ struct merge_options {
         struct hashmap current_file_dir_set;
         struct string_list df_conflict_file_set;
  };
+inline int merge_detect_rename(struct merge_options *o)
+{
+       return o->merge_detect_rename >= 0 ? o->merge_detect_rename :
+               o->diff_detect_rename >= 0 ? o->diff_detect_rename : 1;
+}

Why did you split o->detect_rename into two fields?  You then
recombine them in merge_detect_rename(), and after initial setup only
ever access them through that function.  Having two fields worries me
that people will accidentally introduce bugs by using one of them
instead of the merge_detect_rename() function.  Is there a reason you
decided against having the initial setup just set a single value and
then use it directly?

The setup of this value is split into 3 places that may or may not all get
called.  The initial values, the values that come from the config settings
and then any values passed on the command line.

Because the merge value can now inherit from the diff value, you only know
the final value after you have received all possible inputs.  That makes it
necessary to be a calculated value.

If you look at diff_rename_limit/merge_rename_limit, detect_rename follow
the same pattern for the same reasons.  It turns out detect_rename was a
little more complex because it is used in 3 different locations (vs just
one) which is why I wrapped the inheritance logic into the helper function
merge_detect_rename().

Ah, you're following the precedent set by
diff_rename_limit/merge_rename_limit; that makes sense.  Thanks for
the explanation.  I believe another possibility here is that for both
the {merge,diff}_rename_limit pair of variables and the
{diff,merge}_renames pair of variables, since the code parses all
inputs before ever using the result, we could calculate the result
once and store it rather than storing the constituent pieces of the
calculation.  That would also prevent people from trying to use one of
the pieces of the calculation instead of treating it as a coherent
whole.  However, while I would have preferred that the rename_limit
pair of variables also went away in favor of just one field which is
updated as it parses each input option, what you have is fine for this
series.