Copied all tests and modified them to work with tcl. All pass!

Author: mdaniels5757

src/eval.nix

@@ -8,9 +8,24 @@
   configPath,
 }:
 let
-  # trace = builtins.trace
+  # trace = builtins.trace;
   trace = (e1: e2: e2);
 
+  # https://discourse.nixos.org/t/modify-an-attrset-in-nix/29919/5
+  removeAttrByPath =
+    attrPath: set:
+    pkgs.lib.updateManyAttrsByPath [
+      {
+        path = pkgs.lib.init attrPath;
+        update = old: pkgs.lib.filterAttrs (n: v: n != (pkgs.lib.last attrPath)) old;
+      }
+    ] set;
+  removeAttrsByPaths =
+    set: attrPathStrings:
+    builtins.foldl' (acc: elem: removeAttrByPath elem acc) set (
+      map (s: pkgs.lib.splitString "." s) attrPathStrings
+    );
+
   rawAttrs = trace "rawAttrs = ${(builtins.toJSON (builtins.fromJSON (builtins.readFile attrsPath)))}" (
     builtins.fromJSON (builtins.readFile attrsPath)
   );
@@ -116,12 +131,10 @@ let
   # Information on all attributes that are in a `by-name` directory.
   byNameAttrsForDir =
     byNameDir:
-    pkgs.lib.mergeAttrsList (
-      # pkgs.lib.foldl pkgs.lib.recursiveUpdate { } (
+    builtins.foldl' pkgs.lib.recursiveUpdate { } (
       map (
         package:
         let
-          # attrPath = trace "eval.nix:106: name = ${name}" (pkgs.lib.splitString "." name);
           attrPath = pkgs.lib.splitString "." package.attr_path;
           result = pkgs.lib.setAttrByPath attrPath {
             ByName =
@@ -216,7 +229,7 @@ let
             newName: newValue: markNonByNameAttribute (attrPath ++ [ newName ]) newValue
           ) value;
         in
-        (trace "recursing into name = ${builtins.toJSON pname}" (
+        (trace "recursing into name = ${builtins.toJSON pname}, which has attributes ${builtins.toJSON (builtins.attrNames recursiveResult)}" (
           builtins.seq (trace "result of recursing into ${builtins.toJSON pname}: ${builtins.toJSON recursiveResult}" recursiveResult) (
             trace "done recursing into ${builtins.toJSON pname}" recursiveResult
           )
@@ -241,9 +254,17 @@ let
   # We need this to enforce placement in a `by-name` directory for new packages.
 
   # Second-newest
+  # nonByNameAttrs = (
+  #   builtins.mapAttrs markNonByNameAttribute (
+  #     builtins.removeAttrs pkgs (
+  #       allAttrPaths ++ [ "lib" ] # Need to exclude lib to avoid infinite recursion
+  #     )
+  #   )
+  # );
+
   nonByNameAttrs = (
     builtins.mapAttrs markNonByNameAttribute (
-      builtins.removeAttrs pkgs (
+      removeAttrsByPaths pkgs (
         allAttrPaths ++ [ "lib" ] # Need to exclude lib to avoid infinite recursion
       )
     )
@@ -269,8 +290,80 @@ let
   #   }
   # ) (builtins.removeAttrs pkgs (attrs ++ [ "lib" ])); # Need to exclude lib to avoid infinite recursion
 
+  customMergeAttrs =
+    byName: nonByName:
+    let
+      inherit (builtins) isAttrs;
+      byNameNames = builtins.trace "byNameNames is ${builtins.toJSON (builtins.attrNames byName)}" (
+        builtins.attrNames byName
+      );
+      nonByNameNames = builtins.trace "nonByNameNames is ${builtins.toJSON (builtins.attrNames nonByName)}" (
+        builtins.attrNames nonByName
+      );
+      onlyByName = pkgs.lib.subtractLists nonByNameNames byNameNames;
+      onlyNonByName = pkgs.lib.subtractLists byNameNames nonByNameNames;
+      inBothLists = pkgs.lib.intersectLists byNameNames nonByNameNames;
+    in
+    builtins.listToAttrs (
+      (map (x: {
+        name = x;
+        value = byName.${x};
+      }) onlyByName)
+      ++ (map (x: {
+        name = x;
+        value = nonByName.${x};
+      }) onlyNonByName)
+      ++ (map (
+        x:
+        builtins.trace
+          "x = ${x}; byName.${x} = ${builtins.toJSON byName.${x}}; nonByName.${x} = ${builtins.toJSON nonByName.${x}}"
+          (
+            if
+              !(isAttrs byName.${x}) # And nonByName.${x} is or is not an attrset, we don't care.
+            then
+              {
+                name = x;
+                value = nonByName.${x};
+              }
+            else if !(isAttrs nonByName.${x}) then
+              throw "Shouldn't happen??? "
+            else if byName.${x} ? "ByName" && nonByName.${x} ? "NonByName" then
+              {
+                name = x;
+                value = {
+                  ByName = nonByName.${x}.NonByName;
+                };
+              }
+            else if
+              (builtins.removeAttrs byName.${x} [
+                "NonByName"
+                "ByName"
+              ]) != { }
+              && nonByName.${x} ? "NonByName"
+            then
+              {
+                name = x;
+                value = byName.${x};
+              }
+            else
+              {
+                name = x;
+                value = customMergeAttrs byName.${x} nonByName.${x};
+              }
+          )
+      ) inBothLists)
+    );
+
   # All attributes
-  attributes = byNameAttrs // nonByNameAttrs;
+  # attributes = pkgs.lib.recursiveUpdateUntil (attrPath: left: right:
+  #   trace "eval.nix:293: attrPath ${builtins.toJSON attrPath}; left attrNames are ${if builtins.isAttrs left then (builtins.toJSON (builtins.attrNames left)) else "not an attrset"}; right attrNames are ${if builtins.isAttrs right then builtins.toJSON (builtins.attrNames right) else "not an attrset"}"
+  #     ((builtins.removeAttrs left ["NonByName" "ByName"]) != { } && right ? "NonByName")
+  #     # ||
+  #     # ((left ? "ByName" || left ? "NonByName") && (right ? "ByName" || right ? "NonByName"))
+  #   ) byNameAttrs nonByNameAttrs;
+
+  attributes = customMergeAttrs byNameAttrs nonByNameAttrs;
+
   result =
     pkgs.lib.mapAttrsToListRecursiveCond
       (attrPath: attrValue: !((attrValue ? "NonByName") || (attrValue ? "ByName")))

src/eval.rs

@@ -213,7 +213,7 @@ pub fn check_values(
     let nix_package = env::var("NIXPKGS_VET_NIX_PACKAGE")
         .with_context(|| "Could not get environment variable NIXPKGS_VET_NIX_PACKAGE")?;
 
-    // println!("package_names_path: {package_names_path:?}");
+    println!("packages: {packages:?}");
 
     // With restrict-eval, only paths in NIX_PATH can be accessed. We explicitly specify them here.
     let mut command = process::Command::new(format!("{nix_package}/bin/nix-instantiate"));
@@ -252,15 +252,25 @@ pub fn check_values(
         .output()
         .with_context(|| format!("Failed to run command {command:?}"))?;
 
+    println!(
+        "{}:{}: result (stderr): {}",
+        file!(),
+        line!(),
+        std::str::from_utf8(result.stderr.as_slice()).unwrap()
+    );
+    println!(
+        "{}:{}: result (stdout): {}",
+        file!(),
+        line!(),
+        std::str::from_utf8(result.stdout.as_slice()).unwrap()
+    );
+
     if !result.status.success() {
         // println!("{}:{}: : eval failed for {full_path}", file!(), line!());
         // Early return in case evaluation fails
         return Ok(npv_120::NixEvalError::new(String::from_utf8_lossy(&result.stderr)).into());
     }
 
-    // println!("{}:{}: result (stderr): {}", file!(), line!(), std::str::from_utf8(result.stderr.as_slice()).unwrap());
-    // println!("{}:{}: result (stdout): {}", file!(), line!(), std::str::from_utf8(result.stdout.as_slice()).unwrap());
-
     // Parse the resulting JSON value
     let attributes: Vec<(Vec<String>, Attribute)> = serde_json::from_slice(&result.stdout)
         .with_context(|| {

src/problem/npv_123.rs

@@ -33,7 +33,7 @@ impl fmt::Display for NixFileContainsPathOutsideDirectory {
               Alternatives include:
               - If you are creating a new version of a package with a common file between versions, consider following the recommendation in https://github.com/NixOS/nixpkgs/tree/master/pkgs/by-name#recommendation-for-new-packages-with-multiple-versions.
               - If the path being referenced could be considered a stable interface with multiple uses, consider exposing it via a `pkgs` attribute, then taking it as a attribute argument in {PACKAGE_NIX_FILENAME}.
-              - If the path being referenced is internal and has multiple uses, consider passing the file as an explicit `callPackage` argument in `pkgs/top-level/all-packages.nix`.
+              - If the path being referenced is internal and has multiple uses, consider passing the file as an explicit `callPackage` argument in `pkgs/top-level/all-packages.nix` or equivalent.
               - If the path being referenced is internal and will need to be modified independently of the original, consider copying it into the {relative_package_dir} directory.
             "
         )

src/structure.rs

@@ -227,7 +227,7 @@ pub fn expected_by_name_dir_for_package(attr_path: &str, config: &Config) -> Opt
 //     // Combine the package names contained within each shard into a longer list.
 //     Ok(validation::sequence(shard_results).map(concat))
 // }
-#[derive(Serialize)]
+#[derive(Serialize, Debug)]
 pub struct ByNamePackage<'a> {
     pub attr_path: String,
     /*

tests/mock-nixpkgs.nix

@@ -68,19 +68,10 @@ let
     byNameDir:
     let
       entries = builtins.readDir (
-        builtins.trace
-          "mock-nixpkgs.nix:73: full path = ${
-            (lib.concatStringsSep "/" [
-              (builtins.toString root)
-              byNameDir.path
-            ])
-          }"
-          (
-            lib.concatStringsSep "/" [
-              (builtins.toString root)
-              byNameDir.path
-            ]
-          )
+        lib.concatStringsSep "/" [
+          (builtins.toString root)
+          byNameDir.path
+        ]
       );
 
       namesForShard =
@@ -120,9 +111,8 @@ let
                 ]
               )
             ) fileNames;
-            merged = lib.mergeAttrsList attrSetList;
           in
-          merged;
+          builtins.foldl' lib.recursiveUpdate { } attrSetList;
     in
     builtins.foldl' (acc: el: acc // el) { } (map namesForShard (builtins.attrNames entries));
 
@@ -147,8 +137,8 @@ let
         && (byNameDir.all_packages_path != null)
         && (builtins.pathExists (root + byNameDir.all_packages_path))
       ) byNameDirs;
-      paths = map (byNameDir: byNameDir.all_packages_path) filteredByNameDirs;
-      forEachPath = relativePath: import (root + relativePath);
+      paths = map (byNameDir: (root + byNameDir.all_packages_path)) filteredByNameDirs;
+      forEachPath = path: import path;
     in
     map forEachPath paths;
 

tests/tcl/aliases/expected

@@ -0,0 +1 @@
+Validated successfully

tests/tcl/aliases/main/default.nix

@@ -0,0 +1 @@
+import <test-nixpkgs> { root = ./.; }

tests/tcl/aliases/main/pkgs/development/tcl-modules/by-name/fo/foo/package.nix

@@ -0,0 +1 @@
+{ someDrv }: someDrv

tests/tcl/aliases/main/pkgs/top-level/aliases.nix

@@ -0,0 +1 @@
+self: super: { baz = self.foo; }

tests/tcl/aliases/main/pkgs/top-level/all-packages.nix

@@ -0,0 +1 @@
+self: super: { bar = self.foo; }