When creating actions, normalize paths in the action definition

... and also perform conflict check on the normalized paths. Still,
the the output of the "ACTION" funtion be keyed by the representation
of the paths as originally described, to allow the author of a rule
to use non-normalized paths as well.

2 files changed, 26 insertions, 13 deletions

diff --git a/src/buildtool/build_engine/target_map/built_in_rules.cpp b/src/buildtool/build_engine/target_map/built_in_rules.cpp
index 9a7bb125..51664549 100644
--- a/src/buildtool/build_engine/target_map/built_in_rules.cpp
+++ b/src/buildtool/build_engine/target_map/built_in_rules.cpp
@@ -1106,7 +1106,7 @@ void GenericRuleWithDeps(
                               true);
                     return;
                 }
-                outs.emplace_back(x->String());
+                outs.emplace_back(ToNormalPath(x->String()).string());
             }
         }
     }
@@ -1137,7 +1137,7 @@ void GenericRuleWithDeps(
                         true);
                     return;
                 }
-                out_dirs.emplace_back(x->String());
+                out_dirs.emplace_back(ToNormalPath(x->String()).string());
             }
         }
     }
diff --git a/src/buildtool/build_engine/target_map/target_map.cpp b/src/buildtool/build_engine/target_map/target_map.cpp
index ab6461e3..26935f09 100644
--- a/src/buildtool/build_engine/target_map/target_map.cpp
+++ b/src/buildtool/build_engine/target_map/target_map.cpp
@@ -556,16 +556,29 @@ void withDependencies(
                   throw Evaluator::EvaluationError{
                       "either outs or out_dirs must be specified for ACTION"};
               }
-
-              sort_and_deduplicate(&outputs);
-              sort_and_deduplicate(&output_dirs);
+              ActionDescription::outputs_t outputs_norm{};
+              ActionDescription::outputs_t output_dirs_norm{};
+              outputs_norm.reserve(outputs.size());
+              output_dirs_norm.reserve(output_dirs.size());
+              std::for_each(
+                  outputs.begin(), outputs.end(), [&outputs_norm](auto p) {
+                      outputs_norm.emplace_back(ToNormalPath(p));
+                  });
+              std::for_each(output_dirs.begin(),
+                            output_dirs.end(),
+                            [&output_dirs_norm](auto p) {
+                                output_dirs_norm.emplace_back(ToNormalPath(p));
+                            });
+
+              sort_and_deduplicate(&outputs_norm);
+              sort_and_deduplicate(&output_dirs_norm);
 
               // find entries present on both fields
               std::vector<std::string> dups{};
-              std::set_intersection(outputs.begin(),
-                                    outputs.end(),
-                                    output_dirs.begin(),
-                                    output_dirs.end(),
+              std::set_intersection(outputs_norm.begin(),
+                                    outputs_norm.end(),
+                                    output_dirs_norm.begin(),
+                                    output_dirs_norm.end(),
                                     std::back_inserter(dups));
               if (not dups.empty()) {
                   throw Evaluator::EvaluationError{
@@ -709,8 +722,8 @@ void withDependencies(
                   }
               }
               auto action = BuildMaps::Target::Utils::createAction(
-                  outputs,
-                  output_dirs,
+                  outputs_norm,
+                  output_dirs_norm,
                   std::move(cmd),
                   cwd_exp->String(),
                   env_exp,
@@ -726,13 +739,13 @@ void withDependencies(
                   result.emplace(
                       out,
                       ExpressionPtr{ArtifactDescription::CreateAction(
-                          action_id, std::filesystem::path{out})});
+                          action_id, ToNormalPath(out))});
               }
               for (auto const& out : output_dirs) {
                   result.emplace(
                       out,
                       ExpressionPtr{ArtifactDescription::CreateAction(
-                          action_id, std::filesystem::path{out})});
+                          action_id, ToNormalPath(out))});
               }
 
               return ExpressionPtr{Expression::map_t{result}};