From 4deeb43aa7645dd82863d98b038ff83fafa68ca0 Mon Sep 17 00:00:00 2001
From: Joshua Root <jmr@macports.org>
Date: Mon, 26 Feb 2024 18:31:33 +1100
Subject: [PATCH] Use dict for portinfo, options, variations etc

---
 tools/archive-path.tcl             |  10 +-
 tools/canonical-variants.tcl       |  14 +-
 tools/dependencies.tcl             | 167 ++++++++++----------
 tools/failcache-cleanup.tcl        |   5 +-
 tools/gather-archives.tcl          |   7 +-
 tools/mirror-multi.tcl             |  99 ++++++------
 tools/portgroups.tcl               |  16 +-
 tools/reclaim-space.tcl            |  18 +--
 tools/sort-with-subports.tcl       | 234 +++++++++++++++--------------
 tools/supported-archs.tcl          |  13 +-
 tools/uninstall-unneeded-ports.tcl |  44 +++---
 11 files changed, 305 insertions(+), 322 deletions(-)

diff --git a/tools/archive-path.tcl b/tools/archive-path.tcl
index 1a21e55..7a1bce0 100755
--- a/tools/archive-path.tcl
+++ b/tools/archive-path.tcl
@@ -30,10 +30,10 @@
 # IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 proc split_variants {variants} {
-    set result {}
+    set result [dict create]
     set l [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $variants]
     foreach { match sign variant } $l {
-        lappend result $variant $sign
+        dict set result $variant $sign
     }
     return $result
 }
@@ -59,9 +59,9 @@ if {[catch {set one_result [mportlookup $portname]}] || [llength $one_result] <
     exit 0
 }
 
-array set portinfo [lindex $one_result 1]
-if {[info exists portinfo(porturl)]} {
-    if {[catch {set mport [mportopen $portinfo(porturl) [list subport $portinfo(name)] $variations]}]} {
+lassign $one_result portname portinfo
+if {[dict exists $portinfo porturl]} {
+    if {[catch {set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variations]}]} {
         ui_warn "failed to open port: $portname"
         puts "nonexistent"
         exit 0
diff --git a/tools/canonical-variants.tcl b/tools/canonical-variants.tcl
index 5c0dabe..80ac2fb 100755
--- a/tools/canonical-variants.tcl
+++ b/tools/canonical-variants.tcl
@@ -61,22 +61,22 @@ try {
 }
 
 # parse the given variants from the command line
-array set variants {}
+set variants [dict create]
 foreach item [lrange $::argv 1 end] {
     foreach {_ sign variant} [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $item] {
-        set variants($variant) $sign
+        dict set variants $variant $sign
     }
 }
 
 # open the port to get its active variants
-array set portinfo [lindex $result 1]
+lassign $result portname portinfo
 #try -pass_signal {...}
 try {
-    set mport [mportopen $portinfo(porturl) [list subport $portname] [array get variants]]
+    set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variants]
 } on error {eMessage} {
-    ui_error "mportopen ${portinfo(porturl)} failed: $eMessage"
+    ui_error "mportopen $portname from [dict get $portinfo porturl] failed: $eMessage"
     exit 1
 }
 
-array set info [mportinfo $mport]
-puts $info(canonical_active_variants)
+set portinfo [mportinfo $mport]
+puts [dict get $portinfo canonical_active_variants]
diff --git a/tools/dependencies.tcl b/tools/dependencies.tcl
index 7f3f54b..15d554a 100755
--- a/tools/dependencies.tcl
+++ b/tools/dependencies.tcl
@@ -94,26 +94,26 @@ try {
 }
 
 # parse the given variants from the command line
-array set variants {}
+set variants [dict create]
 foreach item [lrange $::argv 1 end] {
     foreach {_ sign variant} [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $item] {
-        set variants($variant) $sign
+        dict set variants $variant $sign
     }
 }
 
 # open the port so we can run dependency calculation
-array set portinfo [lindex $result 1]
+lassign $result portname portinfo
 #try -pass_signal {...}
 try {
-    set mport [mportopen $portinfo(porturl) [list subport $portinfo(name)] [array get variants]]
+    set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variants]
 } on error {eMessage} {
-    ui_error "mportopen ${portinfo(porturl)} failed: $eMessage"
+    ui_error "mportopen of $portname from [dict get $portinfo porturl] failed: $eMessage"
     exit 2
 }
 
-array set portinfo [mportinfo $mport]
+set portinfo [mportinfo $mport]
 # Also checking for matching archive, in case supported_archs changed
-if {[registry::entry imaged $portinfo(name) $portinfo(version) $portinfo(revision) $portinfo(canonical_active_variants)] ne ""
+if {[registry::entry imaged $portname [dict get $portinfo version] [dict get $portinfo revision] [dict get $portinfo canonical_active_variants]] ne ""
         && [[ditem_key $mport workername] eval [list _archive_available]]} {
     puts "$::argv already installed, not installing or activating dependencies"
     exit 0
@@ -182,12 +182,11 @@ proc check_dep_needs_port {depspec retvar} {
 }
 
 # Get the ports needed by a given port.
-proc collect_deps {portinfovar retvar} {
-    upvar $portinfovar portinfo
+proc collect_deps {portinfo retvar} {
     upvar $retvar ret
     foreach deptype $::recursive_depstypes {
-        if {[info exists portinfo($deptype)]} {
-            foreach depspec $portinfo($deptype) {
+        if {[dict exists $portinfo $deptype]} {
+            foreach depspec [dict get $portinfo $deptype] {
                 check_dep_needs_port $depspec ret
             }
         }
@@ -207,13 +206,10 @@ proc get_maintainers {args} {
             ui_error "mportlookup $portname failed: $eMessage"
             continue
         }
-        array unset portinfo
-        array set portinfo [lindex $result 1]
-        foreach sublist [macports::unobscure_maintainers $portinfo(maintainers)] {
-            foreach {key value} $sublist {
-                if {$key eq "email"} {
-                    lappend retlist $value
-                }
+        set portinfo [lindex $result 1]
+        foreach maintainer [macports::unobscure_maintainers [dict get $portinfo maintainers]] {
+            if {[dict exists $maintainer email]} {
+                lappend retlist [dict get $maintainer email]
             }
         }
     }
@@ -225,26 +221,26 @@ proc open_port {portname} {
         set result [mportlookup $portname]
         if {[llength $result] < 2} {
             ui_error "No such port: $portname"
-            puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (unknown dependency '$portname') maintainers: [get_maintainers $::portname]."
+            puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (unknown dependency '$portname') maintainers: [get_maintainers $::portname]."
             exit 1
         }
     } on error {eMessage} {
         ui_error "mportlookup $portname failed: $eMessage"
         exit 2
     }
-    array set portinfo [lindex $result 1]
+    lassign $result portname portinfo
     try {
-        set mport [mportopen $portinfo(porturl) [list subport $portinfo(name)] [list]]
+        set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] ""]
     } on error {eMessage} {
-        ui_error "mportopen $portinfo(porturl) failed: $eMessage"
+        ui_error "mportopen $portname from [dict get $portinfo porturl] failed: $eMessage"
         exit 2
     }
 
-    if {![info exists ::mportinfo_array($mport)]} {
-        set ::mportinfo_array($mport) [mportinfo $mport]
+    set portinfo [mportinfo $mport]
+    if {![dict exists $::mportinfo_array $mport]} {
+        dict set ::mportinfo_array $mport $portinfo
     }
-    array set portinfo $::mportinfo_array($mport)
-    return [list $mport [array get portinfo]]
+    return [list $mport $portinfo]
 }
 
 # Deactivate the given port, first deactivating any active dependents
@@ -256,41 +252,41 @@ proc deactivate_with_dependents {e} {
     foreach dependent [$e dependents] {
         deactivate_with_dependents $dependent
     }
-    if {![registry::run_target $e deactivate [list ports_nodepcheck 1]]
-              && [catch {portimage::deactivate [$e name] [$e version] [$e revision] [$e variants] [list ports_nodepcheck 1]} result]} {
+    set options [dict create ports_nodepcheck 1]
+    if {![registry::run_target $e deactivate $options]
+              && [catch {portimage::deactivate [$e name] [$e version] [$e revision] [$e variants] $options} result]} {
         puts stderr $::errorInfo
         puts stderr "Deactivating [$e name] @[$e version]_[$e revision][$e variants] failed: $result"
         exit 2
     }
 }
 
-proc deactivate_unneeded {portinfovar} {
-    upvar $portinfovar portinfo
-
+proc deactivate_unneeded {portinfo} {
     # Unfortunately mportdepends doesn't have quite the right semantics
     # to be useful here. It's concerned with what is needed and not
     # present, whereas here we're concerned with removing what we can do
     # without. Future API opportunity?
     set deplist [list]
     foreach deptype $::toplevel_depstypes {
-        if {[info exists portinfo($deptype)]} {
-            foreach depspec $portinfo($deptype) {
+        if {[dict exists $portinfo $deptype]} {
+            foreach depspec [dict get $portinfo $deptype] {
                 check_dep_needs_port $depspec deplist
             }
         }
     }
+    set needed_array [dict create]
+    set mports_array [dict create]
     while {$deplist ne ""} {
         set dep [lindex $deplist end]
         set deplist [lreplace ${deplist}[set deplist {}] end end]
-        if {![info exists needed_array($dep)]} {
-            set needed_array($dep) 1
+        if {![dict exists $needed_array $dep]} {
+            dict set needed_array $dep 1
             set needed [list]
-            lassign [open_port $dep] mports_array($dep) infolist
-            array unset depportinfo
-            array set depportinfo $infolist
-            collect_deps depportinfo needed
+            lassign [open_port $dep] mport depportinfo
+            dict set mports_array $dep $mport
+            collect_deps $depportinfo needed
             foreach newdep $needed {
-                if {![info exists needed_array($newdep)]} {
+                if {![dict exists $needed_array $newdep]} {
                     lappend deplist $newdep
                 }
             }
@@ -305,16 +301,15 @@ proc deactivate_unneeded {portinfovar} {
         # latter will reduce performance for universal installations a
         # bit, but those are much less common and this ensures
         # consistent behaviour.
-        if {![info exists needed_array([$e name])]} {
+        if {![dict exists $needed_array [$e name]]} {
             deactivate_with_dependents $e
         } else {
-            array unset entryinfo
-            array set entryinfo $::mportinfo_array($mports_array([$e name]))
-            if {$entryinfo(version) ne [$e version]
-                    || $entryinfo(revision) != [$e revision]
-                    || $entryinfo(canonical_active_variants) ne [$e variants]} {
+            set entryinfo [dict get $::mportinfo_array [dict get $mports_array [$e name]]]
+            if {[dict get $entryinfo version] ne [$e version]
+                    || [dict get $entryinfo revision] != [$e revision]
+                    || [dict get $entryinfo canonical_active_variants] ne [$e variants]} {
                 lappend dependents_check_list $e
-                puts stderr "[$e name] installed version @[$e version]_[$e revision][$e variants] doesn't match tree version $entryinfo(version)_$entryinfo(revision)$entryinfo(canonical_active_variants)"
+                puts stderr "[$e name] installed version @[$e version]_[$e revision][$e variants] doesn't match tree version [dict get $entryinfo version]_[dict get $entryinfo revision][dict get $entryinfo canonical_active_variants]"
             }
         }
     }
@@ -329,14 +324,15 @@ proc deactivate_unneeded {portinfovar} {
     # earlier - it most likely won't be used again (and will be
     # reopened in the uncommon case that it is needed.)
     foreach e [registry::entry installed] {
-        mportclose $mports_array([$e name])
+        mportclose [dict get $mports_array [$e name]]
     }
 }
 
 puts stderr "init took [expr {[clock seconds] - $start_time}] seconds"
 set start_time [clock seconds]
 
-if {[catch {deactivate_unneeded portinfo} result]} {
+set mportinfo_array [dict create]
+if {[catch {deactivate_unneeded $portinfo} result]} {
     ui_error $::errorInfo
     ui_error "deactivate_unneeded failed: $result"
     exit 2
@@ -360,7 +356,7 @@ if {[catch {mportdepends $mport "activate" 1 1 0 dlist} result]} {
 
 proc append_it {ditem} {
     lappend ::dlist_sorted $ditem
-    set ::mportinfo_array($ditem) [mportinfo $ditem]
+    dict set ::mportinfo_array $ditem [mportinfo $ditem]
     return 0
 }
 try {
@@ -391,12 +387,12 @@ puts $log_status_dependencies ""
 
 ## ensure dependencies are installed and active
 proc checkdep_failcache {ditem} {
-    array set depinfo $::mportinfo_array($ditem)
+    set depinfo [dict get $::mportinfo_array $ditem]
 
-    if {[check_failcache $depinfo(name) [ditem_key $ditem porturl] $depinfo(canonical_active_variants)]} {
-        tee "Dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' has previously failed and is required." $::log_status_dependencies stderr
-        puts "Port $depinfo(name) previously failed in build [check_failcache $depinfo(name) [ditem_key $ditem porturl] $depinfo(canonical_active_variants) yes]"
-        puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to install dependency '$depinfo(name)') maintainers: [get_maintainers $::portname $depinfo(name)]."
+    if {[check_failcache [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants]]} {
+        tee "Dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' has previously failed and is required." $::log_status_dependencies stderr
+        puts "Port [dict get $depinfo name] previously failed in build [check_failcache [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants] yes]"
+        puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to install dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
         # could keep going to report all deps in the failcache, but failing fast seems better
         exit 1
     }
@@ -426,12 +422,12 @@ proc clean_workdirs {} {
 
 # Returns 0 if dep is installed, 1 if not
 proc install_dep_archive {ditem} {
-    array set depinfo $::mportinfo_array($ditem)
+    set depinfo [dict get $::mportinfo_array $ditem]
     incr ::dependencies_counter
-    set msg "Installing dependency ($::dependencies_counter of $::dependencies_count) '$depinfo(name)' with variants '$depinfo(canonical_active_variants)'"
+    set msg "Installing dependency ($::dependencies_counter of $::dependencies_count) '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]'"
     puts -nonewline $::log_status_dependencies "$msg ... "
     puts "----> ${msg}"
-    if {[registry::entry imaged $depinfo(name) $depinfo(version) $depinfo(revision) $depinfo(canonical_active_variants)] ne ""} {
+    if {[registry::entry imaged [dict get $depinfo name] [dict get $depinfo version] [dict get $depinfo revision] [dict get $depinfo canonical_active_variants]] ne ""} {
         puts "Already installed, nothing to do"
         puts $::log_status_dependencies {[OK]}
         return 0
@@ -449,14 +445,14 @@ proc install_dep_archive {ditem} {
     if {$fail || $result > 0 || [$workername eval [list find_portarchive_path]] eq ""} {
         # The known_fail case should normally be caught before now, but
         # it's quick and easy to check and may save a build.
-        if {[info exists depinfo(known_fail)] && [string is true -strict $depinfo(known_fail)]} {
-            puts stderr "Dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' is known to fail, aborting."
+        if {[dict exists $depinfo known_fail] && [string is true -strict [dict get $depinfo known_fail]]} {
+            puts stderr "Dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' is known to fail, aborting."
             puts $::log_status_dependencies {[FAIL] (known_fail)}
-            puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (dependency '$depinfo(name)' known to fail) maintainers: [get_maintainers $::portname $depinfo(name)]."
+            puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (dependency '[dict get $depinfo name]' known to fail) maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
             exit 1
         }
         # This dep will have to be built, not just installed
-        puts stderr "Fetching archive for dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed."
+        puts stderr "Fetching archive for dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed."
         puts $::log_status_dependencies {[MISSING]}
         return 1
     }
@@ -467,9 +463,9 @@ proc install_dep_archive {ditem} {
         set fail 1
     }
     if {$fail || $result > 0} {
-        puts stderr "Installing from archive for dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed, aborting."
+        puts stderr "Installing from archive for dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
         puts $::log_status_dependencies {[FAIL]}
-        puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to install dependency '$depinfo(name)')."
+        puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to install dependency '$depinfo(name)')."
         exit 1
     }
 
@@ -487,10 +483,9 @@ proc close_open_mports {} {
     set macports::open_mports [list]
 }
 
-proc install_dep_source {portinfo_list} {
-    array set depinfo $portinfo_list
+proc install_dep_source {depinfo} {
     incr ::build_counter
-    set msg "Building dependency ($::build_counter of $::build_count) '$depinfo(name)' with variants '$depinfo(canonical_active_variants)'"
+    set msg "Building dependency ($::build_counter of $::build_count) '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]'"
     puts -nonewline $::log_status_dependencies "$msg ... "
     puts "----> ${msg}"
 
@@ -499,15 +494,15 @@ proc install_dep_source {portinfo_list} {
     set macports::channels(info) {}
     close_open_mports
     clean_workdirs
-    array unset ::mportinfo_array
-    set ditem [lindex [open_port $depinfo(name)] 0]
+    set ::mportinfo_array [dict create]
+    set ditem [lindex [open_port [dict get $depinfo name]] 0]
     # Ensure archivefetch is not attempted at all
     set workername [ditem_key $ditem workername]
     $workername eval [list set portutil::archive_available_result 0]
     $workername eval [list archive_sites]
 
     # deactivate ports not needed for this dep
-    if {[catch {deactivate_unneeded depinfo} result]} {
+    if {[catch {deactivate_unneeded $depinfo} result]} {
         ui_error $::errorInfo
         ui_error "deactivate_unneeded failed: $result"
         exit 2
@@ -525,9 +520,9 @@ proc install_dep_source {portinfo_list} {
         set fail 1
     }
     if {$fail || $result > 0} {
-        puts stderr "Fetch of dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed, aborting."
+        puts stderr "Fetch of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
         puts $::log_status_dependencies {[FAIL] (fetch)}
-        puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to fetch dependency '$depinfo(name)') maintainers: [get_maintainers $::portname $depinfo(name)]."
+        puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to fetch dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
         exit 1
     }
     if {[catch {mportexec $ditem checksum} result]} {
@@ -536,9 +531,9 @@ proc install_dep_source {portinfo_list} {
         set fail 1
     }
     if {$fail || $result > 0} {
-        puts stderr "Checksum of dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed, aborting."
+        puts stderr "Checksum of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
         puts $::log_status_dependencies {[FAIL] (checksum)}
-        puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to checksum dependency '$depinfo(name)') maintainers: [get_maintainers $::portname $depinfo(name)]."
+        puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to checksum dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
         exit 1
     }
 
@@ -549,12 +544,12 @@ proc install_dep_source {portinfo_list} {
         set fail 1
     }
     if {$fail || $result > 0} {
-        puts stderr "Build of dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed, aborting."
+        puts stderr "Build of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
         puts $::log_status_dependencies {[FAIL]}
-        puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to install dependency '$depinfo(name)') maintainers: [get_maintainers $::portname $depinfo(name)]."
+        puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to install dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
 
         if {$::failcache_dir ne ""} {
-            failcache_update $depinfo(name) [ditem_key $ditem porturl] $depinfo(canonical_active_variants) 1
+            failcache_update [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants] 1
         }
         ui_debug "Open mports:"
         foreach mport $macports::open_mports {
@@ -565,7 +560,7 @@ proc install_dep_source {portinfo_list} {
 
     # Success. Clear any failcache entry.
     if {$::failcache_dir ne ""} {
-        failcache_update $depinfo(name) [ditem_key $ditem porturl] $depinfo(canonical_active_variants) 0
+        failcache_update [dict get $depinfo name] [ditem_key $ditem porturl] [dict get $depinfo canonical_active_variants] 0
     }
     puts $::log_status_dependencies {[OK]}
 }
@@ -578,7 +573,7 @@ set missing_deps [list]
 try {
     foreach ditem $dlist_sorted {
         if {[install_dep_archive $ditem]} {
-            lappend missing_deps $::mportinfo_array($ditem)
+            lappend missing_deps [dict get $::mportinfo_array $ditem]
         }
     }
 } on error {eMessage} {
@@ -610,15 +605,15 @@ if {$build_count > 0} {
     set macports::channels(debug) {}
     set macports::channels(info) {}
     close_open_mports
-    array unset ::mportinfo_array
+    set ::mportinfo_array [dict create]
     try {
-        set mport [mportopen $portinfo(porturl) [list subport $portinfo(name)] [array get variants]]
+        set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variants]
     } on error {eMessage} {
-        ui_error "mportopen $portinfo(porturl) failed: $eMessage"
+        ui_error "mportopen $portname from [dict get $portinfo porturl] failed: $eMessage"
         exit 2
     }
     [ditem_key $mport workername] eval [list set portutil::archive_available_result 0]
-    if {[catch {deactivate_unneeded portinfo} result]} {
+    if {[catch {deactivate_unneeded $portinfo} result]} {
         ui_error $::errorInfo
         ui_error "deactivate_unneeded failed: $result"
         exit 2
@@ -666,9 +661,9 @@ proc activate_dep {ditem} {
         set fail 1
     }
     if {$fail || $result > 0} {
-        array set depinfo $::mportinfo_array($ditem)
-        puts stderr "Activation of dependency '$depinfo(name)' with variants '$depinfo(canonical_active_variants)' failed, aborting."
-        puts $::log_subports_progress "Building '$::portname' ... \[ERROR\] (failed to activate dependency '$depinfo(name)') maintainers: [get_maintainers $::portname $depinfo(name)]."
+        set depinfo [dict get $::mportinfo_array $ditem]
+        puts stderr "Activation of dependency '[dict get $depinfo name]' with variants '[dict get $depinfo canonical_active_variants]' failed, aborting."
+        puts $::log_subports_progress "Building '$::portname' ... \[FAIL\] (failed to activate dependency '[dict get $depinfo name]') maintainers: [get_maintainers $::portname [dict get $depinfo name]]."
         exit 1
     }
 }
diff --git a/tools/failcache-cleanup.tcl b/tools/failcache-cleanup.tcl
index e840919..fae588b 100755
--- a/tools/failcache-cleanup.tcl
+++ b/tools/failcache-cleanup.tcl
@@ -33,9 +33,8 @@ if {$failcache_dir eq ""} {
         file delete -force [file join $failcache_dir $f]
         continue
     }
-    array unset portinfo
-    array set portinfo [lindex $result 1]
-    set hash [port_files_checksum $portinfo(porturl)]
+    set portinfo [lindex $result 1]
+    set hash [port_files_checksum [dict get $portinfo porturl]]
     if {$entry_hash ne $hash} {
         puts "Removing stale failcache entry: $f"
         file delete -force [file join $failcache_dir $f]
diff --git a/tools/gather-archives.tcl b/tools/gather-archives.tcl
index 3dda4da..79b3ee3 100755
--- a/tools/gather-archives.tcl
+++ b/tools/gather-archives.tcl
@@ -73,11 +73,10 @@ while {[gets $infd line] >= 0} {
         continue
     }
 
-    array unset portinfo
-    array set portinfo [lindex $result 1]
+    lassign $result portname portinfo
 
-    foreach e [registry::entry imaged $portinfo(name)] {
-        if {[$e version] ne $portinfo(version) || [$e revision] != $portinfo(revision)} {
+    foreach e [registry::entry imaged $portname] {
+        if {[$e version] ne [dict get $portinfo version] || [$e revision] != [dict get $portinfo revision]} {
             puts "Skipping [$e name] @[$e version]_[$e revision][$e variants] (not current)"
             continue
         }
diff --git a/tools/mirror-multi.tcl b/tools/mirror-multi.tcl
index 0379d0d..b9a9c90 100755
--- a/tools/mirror-multi.tcl
+++ b/tools/mirror-multi.tcl
@@ -58,13 +58,13 @@ foreach vers {20 21 22 23} {
 }
 set deptypes [list depends_fetch depends_extract depends_patch depends_build depends_lib depends_run depends_test]
 
-array set processed [list]
-array set mirror_done [list]
-array set distfiles_results [list]
+set processed [dict create]
+set mirror_done [dict create]
+set distfiles_results [dict create]
 
 proc check_mirror_done {portname} {
-    if {[info exists ::mirror_done($portname)]} {
-        return $::mirror_done($portname)
+    if {[dict exists $::mirror_done $portname]} {
+        return [dict get $::mirror_done $portname]
     }
     set cache_entry [file join $::mirrorcache_dir [string toupper [string index $portname 0]] $portname]
     if {[file isfile $cache_entry]} {
@@ -72,9 +72,8 @@ proc check_mirror_done {portname} {
         if {[llength $result] < 2} {
             return 0
         }
-        array unset portinfo
-        array set portinfo [lindex $result 1]
-        set portfile [file join [macports::getportdir $portinfo(porturl)] Portfile]
+        set portinfo [lindex $result 1]
+        set portfile [file join [macports::getportdir [dict get $portinfo porturl]] Portfile]
         if {[file isfile $portfile]} {
             set portfile_hash [sha256 file $portfile]
             set fd [open $cache_entry]
@@ -83,29 +82,28 @@ proc check_mirror_done {portname} {
             close $fd
             if {$portfile_hash eq $entry_hash} {
                 if {$partial eq ""} {
-                    set ::mirror_done($portname) 1
+                    dict set ::mirror_done $portname 1
                     return 1
                 } else {
-                    set ::mirror_done($portname) $partial
+                    dict set ::mirror_done $portname $partial
                     return $partial
                 }
             } else {
                 file delete -force $cache_entry
-                set ::mirror_done($portname) 0
+                dict set ::mirror_done $portname 0
             }
         }
     } else {
-        set ::mirror_done($portname) 0
+        dict set ::mirror_done $portname 0
     }
     return 0
 }
 
 proc set_mirror_done {portname value} {
-    if {![info exists ::mirror_done($portname)] || $::mirror_done($portname) != 1} {
+    if {![dict exists $::mirror_done $portname] || [dict get $::mirror_done $portname] != 1} {
         set result [mportlookup $portname]
-        array unset portinfo
-        array set portinfo [lindex $result 1]
-        set portfile [file join [macports::getportdir $portinfo(porturl)] Portfile]
+        set portinfo [lindex $result 1]
+        set portfile [file join [macports::getportdir [dict get $portinfo porturl]] Portfile]
         set portfile_hash [sha256 file $portfile]
 
         set cache_dir [file join $::mirrorcache_dir [string toupper [string index $portname 0]]]
@@ -117,16 +115,15 @@ proc set_mirror_done {portname value} {
             puts $fd $value
         }
         close $fd
-        set ::mirror_done($portname) 1
+        dict set ::mirror_done $portname 1
     }
 }
 
-proc get_dep_list {portinfovar} {
-    upvar $portinfovar portinfo
-    set deps {}
+proc get_dep_list {portinfo} {
+    set deps [list]
     foreach deptype $::deptypes {
-        if {[info exists portinfo($deptype)]} {
-            foreach dep $portinfo($deptype) {
+        if {[dict exists $portinfo $deptype]} {
+            foreach dep [dict get $portinfo $deptype] {
                 lappend deps [lindex [split $dep :] end]
             }
         }
@@ -134,18 +131,14 @@ proc get_dep_list {portinfovar} {
     return $deps
 }
 
-proc get_variants {portinfovar} {
-    upvar $portinfovar portinfo
-    if {![info exists portinfo(vinfo)]} {
+proc get_variants {portinfo} {
+    if {![dict exists $portinfo vinfo]} {
         return {}
     }
     set variants {}
-    array set vinfo $portinfo(vinfo)
-    foreach v [array names vinfo] {
-        array unset variant
-        array set variant $vinfo($v)
-        if {![info exists variant(is_default)] || $variant(is_default) ne "+"} {
-            lappend variants $v
+    dict for {vname variant} [dict get $portinfo vinfo] {
+        if {![dict exists $variant is_default] || [dict get $variant is_default] ne "+"} {
+            lappend variants $vname
         }
     }
     return $variants
@@ -161,7 +154,7 @@ proc save_distfiles_results {mport succeeded} {
     set distpath [_mportkey $mport distpath]
     foreach distfile $all_dist_files {
         set filepath [file join $distpath $distfile]
-        set ::distfiles_results($filepath) $succeeded
+        dict set ::distfiles_results $filepath $succeeded
     }
 }
 
@@ -201,9 +194,9 @@ proc skip_mirror {mport identifier} {
         }
         set distfile [getdistname $distfile]
         set filepath [file join $distpath $distfile]
-        if {![info exists ::distfiles_results($filepath)]} {
+        if {![dict exists $::distfiles_results $filepath]} {
             set any_unmirrored 1
-        } elseif {$::distfiles_results($filepath) == 0} {
+        } elseif {[dict get $::distfiles_results $filepath] == 0} {
             ui_msg "Skipping ${identifier}: $distfile already failed checksum"
             return 2
         }
@@ -216,24 +209,22 @@ proc skip_mirror {mport identifier} {
 }
 
 
-proc mirror_port {portinfo_list} {
-    array set portinfo $portinfo_list
-    set portname $portinfo(name)
-    set porturl $portinfo(porturl)
-    set ::processed($portname) 1
+proc mirror_port {portinfo} {
+    set portname [dict get $portinfo name]
+    set porturl [dict get $portinfo porturl]
+    dict set ::processed $portname 1
     set do_mirror 1
     set attempted 0
     set succeeded 0
-    if {[lsearch -exact -nocase $portinfo(license) "nomirror"] >= 0} {
+    if {[lsearch -exact -nocase [dict get $portinfo license] "nomirror"] >= 0} {
         ui_msg "Not mirroring $portname due to license"
         set do_mirror 0
     }
-    if {[catch {mportopen $porturl [list subport $portname] {}} mport]} {
+    if {[catch {mportopen $porturl [dict create subport $portname] {}} mport]} {
         ui_error "mportopen $porturl failed: $mport"
         return 1
     }
-    array unset portinfo
-    array set portinfo [mportinfo $mport]
+    set portinfo [mportinfo $mport]
 
     set skip_result [skip_mirror $mport $portname]
     if {$do_mirror && $skip_result == 0} {
@@ -251,18 +242,17 @@ proc mirror_port {portinfo_list} {
     }
     mportclose $mport
 
-    set deps [get_dep_list portinfo]
-    set variants [get_variants portinfo]
+    set deps [get_dep_list $portinfo]
+    set variants [get_variants $portinfo]
 
     foreach variant $variants {
         ui_msg "$portname +${variant}"
-        if {[catch {mportopen $porturl [list subport $portname] [list $variant +]} mport]} {
+        if {[catch {mportopen $porturl [dict create subport $portname] [dict create $variant +]} mport]} {
             ui_error "mportopen $porturl failed: $mport"
             continue
         }
-        array unset portinfo
-        array set portinfo [mportinfo $mport]
-        lappend deps {*}[get_dep_list portinfo]
+        set portinfo [mportinfo $mport]
+        lappend deps {*}[get_dep_list $portinfo]
         set skip_result [skip_mirror $mport "$portname +${variant}"]
         if {$do_mirror && $skip_result == 0} {
             incr attempted
@@ -281,13 +271,12 @@ proc mirror_port {portinfo_list} {
 
     foreach {os_major os_arch} $::platforms {
         ui_msg "$portname with platform 'darwin $os_major $os_arch'"
-        if {[catch {mportopen $porturl [list subport $portname os_major $os_major os_arch $os_arch] {}} mport]} {
+        if {[catch {mportopen $porturl [dict create subport $portname os_major $os_major os_arch $os_arch] {}} mport]} {
             ui_error "mportopen $porturl failed: $mport"
             continue
         }
-        array unset portinfo
-        array set portinfo [mportinfo $mport]
-        lappend deps {*}[get_dep_list portinfo]
+        set portinfo [mportinfo $mport]
+        lappend deps {*}[get_dep_list $portinfo]
         set skip_result [skip_mirror $mport "$portname darwin $os_major $os_arch"]
         if {$do_mirror && $skip_result == 0} {
             incr attempted
@@ -306,7 +295,7 @@ proc mirror_port {portinfo_list} {
 
     set dep_failed 0
     foreach dep [lsort -unique $deps] {
-        if {![info exists ::processed($dep)] && [check_mirror_done $dep] == 0} {
+        if {![dict exists $::processed $dep] && [check_mirror_done $dep] == 0} {
             set result [mportlookup $dep]
             if {[llength $result] < 2} {
                 ui_error "No such port: $dep"
@@ -338,7 +327,7 @@ if {[lindex $::argv 0] eq "-c"} {
 
 set exitval 0
 foreach portname $::argv {
-    if {[info exists ::processed($portname)]} {
+    if {[dict exists $::processed $portname]} {
         ui_msg "skipping ${portname}, already processed"
         continue
     }
diff --git a/tools/portgroups.tcl b/tools/portgroups.tcl
index 726f071..393786b 100755
--- a/tools/portgroups.tcl
+++ b/tools/portgroups.tcl
@@ -32,10 +32,10 @@
 # IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 proc split_variants {variants} {
-    set result {}
+    set result [dict create]
     set l [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $variants]
     foreach { match sign variant } $l {
-        lappend result $variant $sign
+        dict set result $variant $sign
     }
     return $result
 }
@@ -74,21 +74,21 @@ try {
 }
 
 # open the port so we can run dependency calculation
-array set portinfo [lindex $result 1]
+lassign $result portname portinfo
 #try -pass_signal {...}
 try {
-    set mport [mportopen $portinfo(porturl) [list subport $portname] $variations]
+    set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variations]
 } on error {eMessage} {
-    ui_error "mportopen ${portinfo(porturl)} failed: $eMessage"
+    ui_error "mportopen for $portname with url [dict get $portinfo porturl] failed: $eMessage"
     exit 1
 }
 
 # obtain PortInfo array for this port and print the list of included
 # PortGroups
-array set portinfo [mportinfo $mport]
+set portinfo [mportinfo $mport]
 # only ports that include at least one PortGroup have portinfo(portgroups) set
-if {[info exists portinfo(portgroups)]} {
-    foreach portgroup $portinfo(portgroups) {
+if {[dict exists $portinfo portgroups]} {
+    foreach portgroup [dict get $portinfo portgroups] {
         lassign $portgroup group version
         puts "$group-$version"
     }
diff --git a/tools/reclaim-space.tcl b/tools/reclaim-space.tcl
index c116349..98a9bd7 100755
--- a/tools/reclaim-space.tcl
+++ b/tools/reclaim-space.tcl
@@ -19,18 +19,18 @@ package require Tclx
 mportinit
 
 random seed
-array set candidates {}
+set candidates [dict create]
 
 fs-traverse -ignoreErrors -- f [list ${macports::portdbpath}/distfiles] {
     if {[file type $f] eq "file"} {
         # 0 for distfile, 1 for port
-        set candidates($f) 0
+        dict set candidates $f 0
     }
 }
 
 foreach port [registry::entry imaged] {
     if {[$port dependents] eq ""} {
-        set candidates($port) 1
+        dict set candidates $port 1
     }
 }
 
@@ -44,7 +44,7 @@ proc active_files_size {port} {
     return $total
 }
 
-set candidate_list [array names candidates]
+set candidate_list [dict keys $candidates]
 # It is tempting to sort by size and delete the largest things first,
 # but picking randomly greatly reduces the chance that we will just
 # uninstall one huge port that will immediately be reinstalled as a
@@ -53,7 +53,7 @@ while {$cur_free < $target && [llength $candidate_list] > 0} {
     set i [random [llength $candidate_list]]
     set chosen [lindex $candidate_list $i]
     set candidate_list [lreplace ${candidate_list}[set candidate_list {}] $i $i]
-    if {$candidates($chosen) == 0} {
+    if {[dict get $candidates $chosen] == 0} {
         set size [file size $chosen]
         incr cur_free $size
         puts "Deleting $chosen ($size bytes)"
@@ -69,14 +69,14 @@ while {$cur_free < $target && [llength $candidate_list] > 0} {
         set deps [$chosen dependencies]
         puts "Uninstalling [$chosen name] @[$chosen version]_[$chosen revision][$chosen variants] ($size bytes)"
         if {!$dryrun} {
-            if {![registry::run_target $chosen uninstall [list]]} {
+            if {![registry::run_target $chosen uninstall ""]} {
                 # Portfile failed, use the registry directly
-                registry_uninstall::uninstall [$chosen name] [$chosen version] [$chosen revision] [$chosen variants] [list]
+                registry_uninstall::uninstall [$chosen name] [$chosen version] [$chosen revision] [$chosen variants] ""
             }
         }
         foreach dep $deps {
-            if {![info exists candidates($dep)] && [$dep dependents] eq ""} {
-                set candidates($dep) 1
+            if {![dict exists $candidates $dep] && [$dep dependents] eq ""} {
+                dict set candidates $dep 1
                 lappend candidate_list $dep
             }
         }
diff --git a/tools/sort-with-subports.tcl b/tools/sort-with-subports.tcl
index 48b709f..be61dd8 100755
--- a/tools/sort-with-subports.tcl
+++ b/tools/sort-with-subports.tcl
@@ -48,14 +48,14 @@ proc ui_channels {priority} {
 
 
 proc process_port_deps {portname} {
-    set deplist $::portdepinfo($portname)
-    unset ::portdepinfo($portname)
-    if {[info exists ::portsoftdeps($portname)]} {
-        lappend deplist {*}$::portsoftdeps($portname)
-        unset ::portsoftdeps($portname)
+    set deplist [dict get $::portdepinfo $portname]
+    dict unset ::portdepinfo $portname
+    if {[dict exists $::portsoftdeps $portname]} {
+        lappend deplist {*}[dict get $::portsoftdeps $portname]
+        dict unset ::portsoftdeps $portname
     }
     foreach portdep $deplist {
-        if {[info exists ::portdepinfo($portdep)]} {
+        if {[dict exists $::portdepinfo $portdep]} {
             process_port_deps $portdep
         }
     }
@@ -63,45 +63,45 @@ proc process_port_deps {portname} {
 }
 
 proc check_failing_deps {portname} {
-    if {[info exists ::failingports($portname)]} {
-        return $::failingports($portname)
+    if {[dict exists ::failingports $portname]} {
+        return [dict get $::failingports $portname]
     }
     # Protect against dependency cycles
-    set ::failingports($portname) [list 3 $portname]
-    foreach portdep $::portdepinfo($portname) {
+    dict set ::failingports $portname [list 3 $portname]
+    foreach portdep [dict get $::portdepinfo $portname] {
         set dep_ret [check_failing_deps $portdep]
         # 0 = ok, 1 = known_fail, 2 = failcache, 3 = dep cycle
         set status [lindex $dep_ret 0]
         if {$status != 0} {
             set failed_dep [lindex $dep_ret 1]
-            if {$::outputports($portname) == 1} {
+            if {[dict get $::outputports $portname] == 1} {
                 if {$status == 1} {
-                    if {[info exists ::requestedports($portname)]} {
-                        puts stderr "Excluding $::canonicalnames($portname) because its dependency '$failed_dep' is known to fail"
+                    if {[dict exists $::requestedports $portname]} {
+                        puts stderr "Excluding [dict get $::canonicalnames $portname] because its dependency '$failed_dep' is known to fail"
                     }
-                    set ::outputports($portname) 0
-                } elseif {$status == 2 && ![info exists ::requestedports($portname)]} {
+                    dict set ::outputports $portname 0
+                } elseif {$status == 2 && ![dict exists $::requestedports $portname]} {
                     # Exclude deps that will fail due to their own dep being in the failcache.
                     # But still output requested ports so the failure will be reported.
-                    set ::outputports($portname) 0
+                    dict set ::outputports $portname 0
                 } elseif {$status == 3} {
-                    if {[info exists ::requestedports($portname)]} {
-                        puts stderr "Warning: $::canonicalnames($portname) appears to have a cyclic dependency involving '$portdep'"
+                    if {[dict exists $::requestedports $portname]} {
+                        puts stderr "Warning: [dict get $::canonicalnames $portname] appears to have a cyclic dependency involving '$portdep'"
                     }
                     # Some cycles involving depends_test exist, which don't cause
                     # problems yet only because we don't run tests.
-                    #set ::outputports($portname) 0
+                    #dict set ::outputports $portname 0
                 }
             }
             # keep processing other deps for now if there was a dep cycle
             if {$status != 3} {
-                set ::failingports($portname) [list $status $failed_dep]
-                return $::failingports($portname)
+                dict set ::failingports $portname [list $status $failed_dep]
+                return [dict get $::failingports $portname]
             }
         }
     }
-    set ::failingports($portname) [list 0 ""]
-    return $::failingports($portname)
+    dict set ::failingports $portname [list 0 ""]
+    return [dict get $::failingports $portname]
 }
 
 source [file join [file dirname [info script]] failcache.tcl]
@@ -158,9 +158,10 @@ if {$jobs_dir ne "" && $archive_site_public ne "" && $archive_site_private ne ""
 
 set is_64bit_capable [sysctl hw.cpu64bit_capable]
 
-array set portdepinfo {}
-array set portsoftdeps {}
-array set canonicalnames {}
+set portdepinfo [dict create]
+set portsoftdeps [dict create]
+set canonicalnames [dict create]
+set failingports [dict create]
 set todo [list]
 if {[lindex $argv 0] eq "-"} {
     while {[gets stdin line] >= 0} {
@@ -172,10 +173,13 @@ if {[lindex $argv 0] eq "-"} {
     }
 }
 # save the ones that the user actually wants to know about
+set inputports [dict create]
+set outputports [dict create]
+set requestedports [dict create]
 foreach p $todo {
-    set inputports($p) 1
-    set outputports($p) 1
-    set requestedports($p) 1
+    dict set inputports $p 1
+    dict set outputports $p 1
+    dict set requestedports $p 1
 }
 # process all recursive deps
 set depstypes [list depends_fetch depends_extract depends_patch depends_build depends_lib depends_run]
@@ -183,87 +187,87 @@ while {[llength $todo] > 0} {
     set p [lindex $todo 0]
     set todo [lreplace ${todo}[set todo {}] 0 0]
 
-    if {![info exists portdepinfo($p)]} {
+    if {![dict exists $portdepinfo $p]} {
         if {[catch {mportlookup $p} result]} {
             puts stderr "$errorInfo"
             error "Failed to find port '$p': $result"
         }
         if {[llength $result] < 2} {
             puts stderr "port $p not found in the index"
-            set portdepinfo($p) [list]
-            set outputports($p) 0
+            dict set portdepinfo $p ""
+            dict set outputports $p 0
             continue
         }
 
-        array set portinfo [lindex $result 1]
+        set portinfo [lindex $result 1]
 
-        if {[info exists inputports($p)]} {
+        if {[dict exists $inputports $p]} {
             if {$failcache_dir ne ""} {
-                failcache_clear_all $portinfo(name)
+                failcache_clear_all [dict get $portinfo name]
             }
-            if {[info exists portinfo(subports)]} {
-                foreach subport $portinfo(subports) {
+            if {[dict exists $portinfo subports]} {
+                foreach subport [dict get $portinfo subports] {
                     set splower [string tolower $subport]
-                    if {![info exists portdepinfo($splower)]} {
+                    if {![dict exists $portdepinfo $splower]} {
                         lappend todo $splower
                     }
-                    if {![info exists requestedports($splower)]} {
-                        set outputports($splower) 1
-                        set requestedports($splower) 1
+                    if {![dict exists $requestedports $splower]} {
+                        dict set outputports $splower 1
+                        dict set requestedports $splower 1
                     }
                 }
             }
         }
 
         set opened 0
-        if {$outputports($p) == 1} {
-            if {[info exists portinfo(replaced_by)]} {
-                if {[info exists requestedports($p)]} {
-                    puts stderr "Excluding $portinfo(name) because it is replaced by $portinfo(replaced_by)"
+        if {[dict get $outputports $p] == 1} {
+            if {[dict exists $portinfo replaced_by]} {
+                if {[dict exists $requestedports $p]} {
+                    puts stderr "Excluding [dict get $portinfo name] because it is replaced by [dict get $portinfo replaced_by]"
                 }
-                set outputports($p) 0
-            } elseif {[info exists portinfo(known_fail)] && [string is true -strict $portinfo(known_fail)]} {
-                if {[info exists requestedports($p)]} {
-                    puts stderr "Excluding $portinfo(name) because it is known to fail"
+                dict set outputports $p 0
+            } elseif {[dict exists $portinfo known_fail] && [string is true -strict [dict get $portinfo known_fail]]} {
+                if {[dict exists $requestedports $p]} {
+                    puts stderr "Excluding [dict get $portinfo name] because it is known to fail"
                 }
-                set outputports($p) 0
-                set failingports($p) [list 1 $portinfo(name)]
-            } elseif {$failcache_dir ne "" && ![info exists requestedports($p)]} {
+                dict set outputports $p 0
+                dict set failingports $p [list 1 [dict get $portinfo name]]
+            } elseif {$failcache_dir ne "" && ![dict exists $requestedports $p]} {
                 # exclude dependencies with a failcache entry
-                if {![catch {mportopen $portinfo(porturl) [list subport $portinfo(name)] ""} result]} {
+                if {![catch {mportopen [dict get $portinfo porturl] [dict create subport [dict get $portinfo name]] ""} result]} {
                     set opened 1
                     set mport $result
-                    array set portinfo [mportinfo $mport]
-                    if {![info exists portinfo(canonical_active_variants)]} {
-                        puts stderr "Warning: $portinfo(name) has no canonical_active_variants"
-                        set outputports($p) 0
-                    } elseif {[check_failcache $portinfo(name) $portinfo(porturl) $portinfo(canonical_active_variants)] != 0} {
-                        set outputports($p) 0
-                        set failingports($p) [list 2 $portinfo(name)]
+                    set portinfo [mportinfo $mport]
+                    if {![dict exists $portinfo canonical_active_variants]} {
+                        puts stderr "Warning: [dict get $portinfo name] has no canonical_active_variants"
+                        dict set outputports $p 0
+                    } elseif {[check_failcache [dict get $portinfo name] [dict get $portinfo porturl] [dict get $portinfo canonical_active_variants]] != 0} {
+                        dict set outputports $p 0
+                        dict set failingports $p [list 2 [dict get $portinfo name]]
                     }
                 } else {
-                    set outputports($p) 0
+                    dict set outputports $p 0
                 }
             }
-            if {$archive_site_public ne "" && $outputports($p) == 1} {
+            if {$archive_site_public ne "" && [dict get $outputports $p] == 1} {
                 # FIXME: support non-default variants
-                if {$opened == 1 || ![catch {mportopen $portinfo(porturl) [list subport $portinfo(name)] ""} result]} {
+                if {$opened == 1 || ![catch {mportopen [dict get $portinfo porturl] [dict create subport [dict get $portinfo name]] ""} result]} {
                     if {$opened != 1} {
                         set opened 1
                         set mport $result
-                        array set portinfo [mportinfo $mport]
+                        set portinfo [mportinfo $mport]
                     }
                     set workername [ditem_key $mport workername]
                     set archive_name [$workername eval {get_portimage_name}]
                     set archive_name_encoded [portfetch::percent_encode $archive_name]
-                    if {![catch {curl getsize ${archive_site_public}/$portinfo(name)/${archive_name_encoded}} size] && $size > 0} {
+                    if {![catch {curl getsize ${archive_site_public}/[dict get $portinfo name]/${archive_name_encoded}} size] && $size > 0} {
                         # Check for other installed variants that might not have been uploaded
-                        set archives_prefix ${macports::portdbpath}/software/$portinfo(name)/$portinfo(name)-$portinfo(version)_$portinfo(revision)
+                        set archives_prefix ${macports::portdbpath}/software/[dict get $portinfo name]/[dict get $portinfo name]-[dict get $portinfo version]_[dict get $portinfo revision]
                         set any_archive_missing 0
                         foreach installed_archive [glob -nocomplain -tails -path ${archives_prefix} *] {
                             if {$installed_archive ne $archive_name} {
                                 set installed_archive_encoded [portfetch::percent_encode $installed_archive]
-                                if {[catch {curl getsize ${archive_site_public}/$portinfo(name)/${installed_archive_encoded}} size] || $size <= 0} {
+                                if {[catch {curl getsize ${archive_site_public}/[dict get $portinfo name]/${installed_archive_encoded}} size] || $size <= 0} {
                                     set any_archive_missing 1
                                     puts stderr "$installed_archive installed but not uploaded"
                                     break
@@ -271,75 +275,75 @@ while {[llength $todo] > 0} {
                             }
                         }
                         if {!$any_archive_missing} {
-                            if {[info exists requestedports($p)]} {
-                                puts stderr "Excluding $portinfo(name) because it has already been built and uploaded to the public server"
+                            if {[dict exists $requestedports $p]} {
+                                puts stderr "Excluding [dict get $portinfo name] because it has already been built and uploaded to the public server"
                             }
-                            set outputports($p) 0
+                            dict set outputports $p 0
                         }
                     }
                 } else {
-                    if {[info exists requestedports($p)]} {
-                        puts stderr "Excluding $portinfo(name) because it failed to open: $result"
+                    if {[dict exists $requestedports $p]} {
+                        puts stderr "Excluding [dict get $portinfo name] because it failed to open: $result"
                     }
-                    set outputports($p) 0
+                    dict set outputports $p 0
                 }
-                if {$outputports($p) == 1 && $archive_site_private ne "" && $jobs_dir ne ""} {
+                if {[dict get $outputports $p] == 1 && $archive_site_private ne "" && $jobs_dir ne ""} {
                     # FIXME: support non-default variants
-                    set results [check_licenses $portinfo(name) [list]]
-                    if {[lindex $results 0] == 1 && ![catch {curl getsize ${archive_site_private}/$portinfo(name)/${archive_name_encoded}} size] && $size > 0} {
-                        if {[info exists requestedports($p)]} {
-                            puts stderr "Excluding $portinfo(name) because it is not distributable and it has already been built and uploaded to the private server"
+                    set results [check_licenses [dict get $portinfo name] [list]]
+                    if {[lindex $results 0] == 1 && ![catch {curl getsize ${archive_site_private}/[dict get $portinfo name]/${archive_name_encoded}} size] && $size > 0} {
+                        if {[dict exists $requestedports $p]} {
+                            puts stderr "Excluding [dict get $portinfo name] because it is not distributable and it has already been built and uploaded to the private server"
                         }
-                        set outputports($p) 0
+                        dict set outputports $p 0
                     }
                 }
             }
-            if {$outputports($p) == 1 &&
+            if {[dict get $outputports $p] == 1 &&
                 ($::macports::os_major <= 10 || $::macports::os_major >= 18)} {
-                if {$opened == 1 || ![catch {mportopen $portinfo(porturl) [list subport $portinfo(name)] ""} result]} {
+                if {$opened == 1 || ![catch {mportopen [dict get $portinfo porturl] [dict create subport [dict get $portinfo name]] ""} result]} {
                     if {$opened != 1} {
                         set opened 1
                         set mport $result
-                        array set portinfo [mportinfo $mport]
+                        set portinfo [mportinfo $mport]
                     }
                     set supported_archs [_mportkey $mport supported_archs]
                     switch $::macports::os_arch {
                         arm {
                             if {$supported_archs ne "" && $supported_archs ne "noarch" && "arm64" ni $supported_archs} {
-                                if {[info exists requestedports($p)]} {
-                                    puts stderr "Excluding $portinfo(name) because it does not support the arm64 arch"
+                                if {[dict exists $requestedports $p]} {
+                                    puts stderr "Excluding [dict get $portinfo name] because it does not support the arm64 arch"
                                 }
-                                set outputports($p) 0
+                                dict set outputports $p 0
                             }
                         }
                         i386 {
                             if {${is_64bit_capable}} {
                                 if {$::macports::os_major >= 18 && $supported_archs ne "" && $supported_archs ne "noarch" && "x86_64" ni $supported_archs} {
-                                    if {[info exists requestedports($p)]} {
-                                        puts stderr "Excluding $portinfo(name) because it does not support the x86_64 arch"
+                                    if {[dict exists $requestedports $p]} {
+                                        puts stderr "Excluding [dict get $portinfo name] because it does not support the x86_64 arch"
                                     }
-                                    set outputports($p) 0
+                                    dict set outputports $p 0
                                 }
                             } elseif {$supported_archs ne "" && $supported_archs ne "noarch" && ("x86_64" ni $supported_archs || "i386" ni $supported_archs)} {
-                                if {[info exists requestedports($p)]} {
-                                    puts stderr "Excluding $portinfo(name) because the ${::macports::macosx_version}_x86_64 builder will build it"
+                                if {[dict exists $requestedports $p]} {
+                                    puts stderr "Excluding [dict get $portinfo name] because the ${::macports::macosx_version}_x86_64 builder will build it"
                                 }
-                                set outputports($p) 0
+                                dict set outputports $p 0
                             }
                         }
                         powerpc {
                             if {$supported_archs ne "" && $supported_archs ne "noarch" && "ppc" ni $supported_archs} {
-                                if {[info exists requestedports($p)]} {
-                                    puts stderr "Excluding $portinfo(name) because it does not support the ppc arch"
+                                if {[dict exists $requestedports $p]} {
+                                    puts stderr "Excluding [dict get $portinfo name] because it does not support the ppc arch"
                                 }
-                                set outputports($p) 0
+                                dict set outputports $p 0
                             }
                         }
                         default {}
                     }
                 } else {
-                    puts stderr "Excluding $portinfo(name) because it failed to open: $result"
-                    set outputports($p) 0
+                    puts stderr "Excluding [dict get $portinfo name] because it failed to open: $result"
+                    dict set outputports $p 0
                 }
             }
         }
@@ -348,34 +352,34 @@ while {[llength $todo] > 0} {
             mportclose $mport
         }
 
-        if {$outputports($p) == 1} {
-            set canonicalnames($p) $portinfo(name)
+        if {[dict get $outputports $p] == 1} {
+            dict set canonicalnames $p [dict get $portinfo name]
         }
 
         # If $requestedports($p) == 0, we're seeing the port again as a dependency of
         # something else and thus need to follow its deps even if it was excluded.
-        if {$outputports($p) == 1 || ![info exists requestedports($p)] || $requestedports($p) == 0} {
-            set portdepinfo($p) [list]
+        if {[dict get $outputports $p] == 1 || ![dict exists $requestedports $p] || [dict get $requestedports $p] == 0} {
+            dict set portdepinfo $p [list]
             foreach depstype $depstypes {
-                if {[info exists portinfo($depstype)] && $portinfo($depstype) ne ""} {
-                    foreach onedep $portinfo($depstype) {
+                if {[dict exists $portinfo $depstype] && [dict get $portinfo $depstype] ne ""} {
+                    foreach onedep [dict get $portinfo $depstype] {
                         set depname [string tolower [lindex [split [lindex $onedep 0] :] end]]
                         if {[string match port:* $onedep]} {
-                            lappend portdepinfo($p) $depname
+                            dict lappend portdepinfo $p $depname
                         } else {
                             # soft deps are installed before their dependents, but
                             # don't cause exclusion if they are failing
                             # real problematic example: bin:xattr:xattr
-                            lappend portsoftdeps($p) $depname
+                            dict lappend portsoftdeps $p $depname
                         }
-                        if {![info exists outputports($depname)]} {
+                        if {![dict exists $outputports $depname]} {
                             lappend todo $depname
                             if {$include_deps} {
-                                set outputports($depname) 1
+                                dict set outputports $depname 1
                             } else {
-                                set outputports($depname) 0
+                                dict set outputports $depname 0
                             }
-                        } elseif {[info exists requestedports($depname)] && ![info exists portdepinfo($depname)]} {
+                        } elseif {[dict exists $requestedports $depname] && ![dict exists $portdepinfo $depname]} {
                             # may or may not have been checked for exclusion yet
                             lappend todo $depname
                         }
@@ -385,11 +389,9 @@ while {[llength $todo] > 0} {
         }
 
         # Mark as having been processed at least once.
-        if {[info exists requestedports($p)]} {
-            set requestedports($p) 0
+        if {[dict exists $requestedports $p]} {
+            dict set requestedports $p 0
         }
-
-        array unset portinfo
     }
 }
 
@@ -397,20 +399,20 @@ if {$jobs_dir ne "" && $license_db_dir ne "" && $archive_site_public ne "" && $a
     write_license_db $license_db_dir
 }
 
-set sorted_portnames [lsort -dictionary [array names portdepinfo]]
+set sorted_portnames [lsort -dictionary [dict keys $portdepinfo]]
 foreach portname $sorted_portnames {
     check_failing_deps $portname
 }
 
 set portlist [list]
 foreach portname $sorted_portnames {
-   if {[info exists portdepinfo($portname)]} {
+   if {[dict exists $portdepinfo $portname]} {
       process_port_deps $portname
    }
 }
 
 foreach portname $portlist {
-    if {$outputports($portname) == 1} {
-        puts $canonicalnames($portname)
+    if {[dict get $outputports $portname] == 1} {
+        puts [dict get $canonicalnames $portname]
     }
 }
diff --git a/tools/supported-archs.tcl b/tools/supported-archs.tcl
index 29b421e..106bb86 100755
--- a/tools/supported-archs.tcl
+++ b/tools/supported-archs.tcl
@@ -31,10 +31,10 @@
 # IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 proc split_variants {variants} {
-    set result {}
+    set result [dict create]
     set l [regexp -all -inline -- {([-+])([[:alpha:]_]+[\w\.]*)} $variants]
     foreach { match sign variant } $l {
-        lappend result $variant $sign
+        dict set result $variant $sign
     }
     return $result
 }
@@ -64,14 +64,13 @@ if {[catch {set one_result [mportlookup $portname]}] || [llength $one_result] <
     exit 1
 }
 
-array set portinfo [lindex $one_result 1]
-set portname $portinfo(name)
+lassign $one_result portname portinfo
 
-if {[info exists portinfo(porturl)]} {
-    if {[catch {set mport [mportopen $portinfo(porturl) [list subport $portname] $variations]}]} {
+if {[dict exists $portinfo porturl]} {
+    if {[catch {set mport [mportopen [dict get $portinfo porturl] [dict create subport $portname] $variations]}]} {
         ui_warn "failed to open port: $portname"
     } else {
         set archs [_mportkey $mport supported_archs]
-        puts [expr {$archs ne "" ? $archs : "x86_64 i386 ppc64 ppc"}]
+        puts [expr {$archs ne "" ? $archs : "arm64 i386 ppc ppc64 x86_64"}]
     }
 }
diff --git a/tools/uninstall-unneeded-ports.tcl b/tools/uninstall-unneeded-ports.tcl
index a7594f9..4cc052a 100755
--- a/tools/uninstall-unneeded-ports.tcl
+++ b/tools/uninstall-unneeded-ports.tcl
@@ -41,6 +41,8 @@ if {$showVersion} {
 
 # Create a lookup table for determining whether a port has dependents
 # (regardless of whether or not those dependents are currently installed)
+set dependents [dict create]
+set a_dependency [dict create]
 foreach source $macports::sources {
     set source [lindex $source 0]
     macports_try -pass_signal {
@@ -48,19 +50,16 @@ foreach source $macports::sources {
 
         macports_try -pass_signal {
             while {[gets $fd line] >= 0} {
-                array unset portinfo
-                set name [lindex $line 0]
-                set len  [lindex $line 1]
-                set line [read $fd $len]
-                array set portinfo $line
+                lassign $line name len
+                set portinfo [read $fd $len]
 
                 # depends_test is not included because mpbb doesn't run `port test'
-                foreach field {depends_build depends_extract depends_fetch depends_lib depends_patch depends_run} {
-                    if {[info exists portinfo($field)]} {
-                        foreach dependency $portinfo($field) {
+                foreach field [list depends_build depends_extract depends_fetch depends_lib depends_patch depends_run] {
+                    if {[dict exists $portinfo $field]} {
+                        foreach dependency [dict get $portinfo $field] {
                             set lowercase_dependency_name [string tolower [lindex [split $dependency :] end]]
-                            incr dependents($lowercase_dependency_name)
-                            set a_dependency($lowercase_dependency_name) $name
+                            dict incr dependents $lowercase_dependency_name
+                            dict set a_dependency $lowercase_dependency_name $name
                         }
                     }
                 }
@@ -80,12 +79,12 @@ proc removal_reason {installed_name} {
     global dependents a_dependency
     set reason ""
     set lowercase_name [string tolower $installed_name]
-    if {![info exists dependents($lowercase_name)]} {
+    if {![dict exists $dependents $lowercase_name]} {
         set reason "no port in the PortIndex depends on $installed_name"
-    } elseif {$dependents($lowercase_name) == 1} {
-        set dependency_reason [removal_reason $a_dependency($lowercase_name)]
+    } elseif {[dict get $dependents $lowercase_name] == 1} {
+        set dependency_reason [removal_reason [dict get $a_dependency $lowercase_name]]
         if {$dependency_reason ne ""} {
-            set reason "only $a_dependency($lowercase_name) depends on $installed_name and $dependency_reason"
+            set reason "only [dict get $a_dependency $lowercase_name] depends on $installed_name and $dependency_reason"
         }
     }
     return $reason
@@ -100,13 +99,15 @@ proc deactivate_with_dependents {e} {
     foreach dependent [$e dependents] {
         deactivate_with_dependents $dependent
     }
-    if {![registry::run_target $e deactivate [list ports_nodepcheck 1]]
-              && [catch {portimage::deactivate [$e name] [$e version] [$e revision] [$e variants] [list ports_nodepcheck 1]} result]} {
+    set options [dict create ports_nodepcheck 1]
+    if {![registry::run_target $e deactivate $options]
+              && [catch {portimage::deactivate [$e name] [$e version] [$e revision] [$e variants] $options} result]} {
         puts stderr $::errorInfo
         puts stderr "Deactivating [$e name] @[$e version]_[$e revision][$e variants] failed: $result"
     }
 }
 
+set uninstall_options [dict create ports_force 1]
 foreach port [registry::entry imaged] {
     # Set to yes if a port should be uninstalled
     set uninstall no
@@ -122,11 +123,10 @@ foreach port [registry::entry imaged] {
         ui_msg "Removing ${installed_name} @${installed_version}_${installed_revision}${installed_variants} because it is no longer in the PortIndex"
         set uninstall yes
     } else {
-        array unset portinfo
-        array set portinfo [lindex $portindex_match 1]
+        set portinfo [lindex $portindex_match 1]
 
         set portspec "$installed_name @${installed_version}_$installed_revision$installed_variants"
-        if {$portinfo(version) ne $installed_version || $portinfo(revision) != $installed_revision} {
+        if {[dict get $portinfo version] ne $installed_version || [dict get $portinfo revision] != $installed_revision} {
             # The version in the index is different than the installed one
             ui_msg "Removing $portspec because there is a newer version in the PortIndex"
             set uninstall yes
@@ -139,7 +139,7 @@ foreach port [registry::entry imaged] {
                 set uninstall no
                 if {no} {
                     set lowercase_name [string tolower $installed_name]
-                    ui_msg "Not removing $portspec because it has $dependents($lowercase_name) dependents"
+                    ui_msg "Not removing $portspec because it has [dict get $dependents $lowercase_name] dependents"
                 }
             }
         }
@@ -150,9 +150,9 @@ foreach port [registry::entry imaged] {
             deactivate_with_dependents $dependent
         }
         # Try to run the target via the portfile first, so pre/post code runs
-        if {![registry::run_target $port uninstall [list ports_force 1]]} {
+        if {![registry::run_target $port uninstall $uninstall_options]} {
             # Portfile failed, use the registry directly
-            registry_uninstall::uninstall $installed_name $installed_version $installed_revision $installed_variants [list ports_force 1]
+            registry_uninstall::uninstall $installed_name $installed_version $installed_revision $installed_variants $uninstall_options
         }
     }
 }