Fails to load multiple times on ABCL

[pnathan]

As the cl-test-grid maintainer recently noted[1,2], a bug exists in cl-containers on ABCL, where it will outright refuse to load due to abstract-container not being found.

A short-cut to fix this is given here, but I don't think it's a valid fix.

./dev/utilities-integration.lisp    
@@ -3,5 +3,7 @@
 (eval-when (:compile-toplevel)
   (export-exported-symbols '#:cl-containers '#:metatilities))

+#+(not abcl)(make-load-form* containers:abstract-container)
-(make-load-form* containers:abstract-container)
 (make-load-form* containers:container-node-mixin)

Note that we can conditionally avoid loading abstract-container, but still load the container-node-mixin. Further, both abstract container and container-node-mixin are still visible in ABCL with this patch applied:

CL-USER(2): (find-class 'cl-containers:container-node-mixin)
#<STANDARD-CLASS METABANG.CL-CONTAINERS:CONTAINER-NODE-MIXIN {1C387BAC}>
CL-USER(3): (find-class 'cl-containers:abstract-container)
#<STANDARD-CLASS METABANG.CL-CONTAINERS:ABSTRACT-CONTAINER {BBBFA09}>

Please advise on the purpose of make-load-form*. I would really quite like to use cl-container in ABCL.

[1] Copy from the mailing list, which appears to have issues with its archive feature...

---

The only suspicious bug is cl-containers in the second report.
But I guess it's not a regressions, the problem happens on the
previous ABCL versions too.

I tested it manually on ABCL 1.2.1, 1.3.0 and 1.3.1-rc.
When you quickload cl-containers first time, it compiles OK.
When you quickload it second time, it fails with the error
"no class named ABSTRACT-CONTAINER".

The difference in test results may be caused by different
build order of quicklisp libraries when testing on ABCL 1.3.0 and 1.3.1-rc,
because some libraries and their dependencies fail on one ABCL
but succeed on another.

---

[2] http://common-lisp.net/project/cl-test-grid/abcl/abcl-diff22.html

[fare]

Gary, are you here to handle that?

I could push your patch (using #-abcl rather than #+(not abcl)), but I'm not sure what the code does and why your patch fixes things. Can you explain how you came up with that patch?

[pnathan]

I hunted down the failure and traced it to this point. Adding #-abcl made the problem go away(what I use cl containers for didn't break and I could load cl containers) .

But I would be really unhappy if this patch was pushed quickly, as it REALLY needs a bit of root cause analysis IMO. I am sure the code does something vital I haven't needed yet.

---

Regards,
Paul

Sent from my phone.

[fare]

I'll give a few days to Gary so he may comment, as I am wholly unfamiliar with this part of the code.

If you need something urgent, I propose you use a git branch in the mean time. Sorry.

[fare]

make-load-form* is defined in metatilities-base/dev/generic-lisp.lisp, and should expand to
(defmethod make-load-form ((self ,class-name) &optional environment)
(declare (ignore environment))
(make-load-form-saving-slots self))

How is that causing a problem for containers:abstract-container but not for containers:container-node-mixin ??? They are both defined by similar defclass* forms in the same file containers.lisp!!!

Can you submit a backtrace? Or is it a matter of you using one and not the other, with a runtime error?

[pnathan]

Those are great questions! There is an illogicity to the matter.

It's been a few months since I patched in the hack in on my development machine and only brought it up since I saw avodonsov's remark on the abcl-devel mailing list the other day.

Anyway, for reproducing this morning - I removed cl-containers from quicklisp and reloaded.

What appears to be happening is that cl-containers is loading correctly the first time and failing the second time (when the ABCL FASL is invoked). Some nuanced interaction appears to be occuring in the make-load-saving-form call related to the FASL format and loading, I suspect.

Using 1.0.1 and 1.3.0 ABCL I can reproduce this issue, but I have to remove both forms to load the FASL. I'm not sure how I was getting away with only commenting out one form. One variance between then and now is upgrading Java to 1.8.

#-abcl(make-load-form* containers:abstract-container)
#-abcl(make-load-form* containers:container-node-mixin)

At any rate, I have a backtrace included below, it's dreadfully dreary reading.

To reproduce, follow these steps:

1. Install Java
2. Download ABCL and run it.
3. Install Quicklisp
4. Evaluate (ql:quickload :cl-containers) in a REPL (Slime or on terminal, doesn't matter)
5. Quit ABCL.
6. Load ABCL
7. Evaluate (ql:quickload :cl-containers) again.
8. The condition is thrown.

The error does not go away when the TRY-RECOMPILING restart is selected; this yields a condition about the classname already existing in metabang-utilities, e.g.:

A symbol named CONTAINER-NODE-MIXIN is already accessible in package METABANG.UTILITIES.

I find this particular error interesting, as it suggests to my slightly undercaffinated mind that the symbol is not being created in the correct pacakge. But, I don't know the deep code semantics here that are being shuffled around and thus might be quite wrong.

Backtrace:

;;; from within SLIME, after evaling (ql:quickload :cl-containers) from a buffer

;; There is no class named ABSTRACT-CONTAINER.
;;    [Condition of type ERROR]

;; Restarts:
;;  0: [TRY-RECOMPILING] Recompile utilities-integration and try loading it again
;;  1: [RETRY] Retry loading FASL for #<ASDF/LISP-ACTION:CL-SOURCE-FILE "containers-and-utilities" "dev" "utilities-integration">.
;;  2: [ACCEPT] Continue, treating loading FASL for #<ASDF/LISP-ACTION:CL-SOURCE-FILE "containers-and-utilities" "dev" "utilities-integration"> as having been successful.
;;  3: [ABORT] Give up on "cl-containers"
;;  4: [RETRY] Retry SLIME interactive evaluation request.
;;  5: [*ABORT] Return to SLIME's top level.
;;  --more--

;; Backtrace:
;;   0: (#<FUNCTION {277D8CB4}> #<ERROR {C523600}> #<FUNCTION {277D8CB4}>)
;;   1: (APPLY #<FUNCTION {277D8CB4}> (#<ERROR {C523600}> #<FUNCTION {277D8CB4}>))
;;   2: (SYSTEM::RUN-HOOK SYSTEM::*INVOKE-DEBUGGER-HOOK* #<ERROR {C523600}> #<FUNCTION {277D8CB4}>)
;;   3: (INVOKE-DEBUGGER #<ERROR {C523600}>)
;;   4: org.armedbear.lisp.Lisp.error(Lisp.java:382)
;;   5: org.armedbear.lisp.LispClass.findClass(LispClass.java:80)
;;   6: org.armedbear.lisp.clos_250.execute(clos.lisp:1922)
;;   7: org.armedbear.lisp.Symbol.execute(Symbol.java:803)
;;   8: org.armedbear.lisp.LispThread.execute(LispThread.java:814)
;;   9: org.armedbear.lisp.clos_249.execute(clos.lisp:1919)
;;  10: org.armedbear.lisp.LispThread.execute(LispThread.java:814)
;;  11: org.armedbear.lisp.Lisp.evalCall(Lisp.java:575)
;;  12: org.armedbear.lisp.Lisp.eval(Lisp.java:540)
;;  13: org.armedbear.lisp.Lisp.evalCall(Lisp.java:613)
;;  14: org.armedbear.lisp.Lisp.eval(Lisp.java:540)
;;  15: org.armedbear.lisp.Load.faslLoadStream(Load.java:667)
;;  16: org.armedbear.lisp.Load$init_fasl.execute(Load.java:457)
;;  17: org.armedbear.lisp.LispThread.execute(LispThread.java:832)
;;  18: org.armedbear.lisp.Lisp.evalCall(Lisp.java:582)
;;  19: org.armedbear.lisp.Lisp.eval(Lisp.java:540)
;;  20: org.armedbear.lisp.Load.loadStream(Load.java:629)
;;  21: org.armedbear.lisp.Load.loadFileFromStream(Load.java:597)
;;  22: org.armedbear.lisp.Load.load(Load.java:224)
;;  23: org.armedbear.lisp.Load.load(Load.java:745)
;;  24: org.armedbear.lisp.Load$_load.execute(Load.java:693)
;;  25: org.armedbear.lisp.Symbol.execute(Symbol.java:852)
;;  26: org.armedbear.lisp.LispThread.execute(LispThread.java:894)
;;  27: org.armedbear.lisp.load_1.execute(load.lisp:33)
;;  28: org.armedbear.lisp.CompiledClosure.execute(CompiledClosure.java:98)
;;  29: org.armedbear.lisp.Symbol.execute(Symbol.java:803)
;;  30: org.armedbear.lisp.LispThread.execute(LispThread.java:814)
;;  31: org.armedbear.lisp.Lisp.funcall(Lisp.java:172)
;;  32: org.armedbear.lisp.Primitives$pf_apply.execute(Primitives.java:2827)
;;  33: (MOP::CANONICALIZE-SPECIALIZER METABANG.UTILITIES::ABSTRACT-CONTAINER)
;;  34: (MOP::CANONICALIZE-SPECIALIZERS (METABANG.UTILITIES::ABSTRACT-CONTAINER))
;;  35: (SYSTEM:INIT-FASL :VERSION 42)
;;  36: (SYSTEM::%LOAD #P"/Users/pnathan/.cache/common-lisp/abcl-1.3.0-fasl42-macosx-x64/Users/pnathan/quicklisp/dists/quicklisp/software/cl-containers-20140211-git/dev/utilities-integration.abcl" NIL NIL T :DEFA..
;;  37: (LOAD #P"/Users/pnathan/.cache/common-lisp/abcl-1.3.0-fasl42-macosx-x64/Users/pnathan/quicklisp/dists/quicklisp/software/cl-containers-20140211-git/dev/utilities-integration.abcl")
;;  38: (APPLY LOAD #P"/Users/pnathan/.cache/common-lisp/abcl-1.3.0-fasl42-macosx-x64/Users/pnathan/quicklisp/dists/quicklisp/software/cl-containers-20140211-git/dev/utilities-integration.abcl" NIL)
;;  39: (#<FUNCTION {6A899404}>)
;;  40: (UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS #<FUNCTION {6A899404}> ("Overwriting already existing readtable ~S." #(#:FINALIZERS-OFF-WARNING :ASDF-FINALIZERS)))
;;  41: (UIOP/LISP-BUILD:CALL-WITH-MUFFLED-LOADER-CONDITIONS #<FUNCTION {6A899404}>)
;;  42: (UIOP/LISP-BUILD:LOAD* #P"/Users/pnathan/.cache/common-lisp/abcl-1.3.0-fasl42-macosx-x64/Users/pnathan/quicklisp/dists/quicklisp/software/cl-containers-20140211-git/dev/utilities-integration.abcl")
;;  43: (ASDF/LISP-ACTION:PERFORM-LISP-LOAD-FASL #<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/LISP-ACTION:CL-SOURCE-FILE {6C9BEC4B}>)
;;  44: (ASDF/ACTION:PERFORM #<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/LISP-ACTION:CL-SOURCE-FILE {6C9BEC4B}>)
;;  45: (#<FUNCTION (LAMBDA (MOP::ARGS MOP::NEXT-EMFUN)) {32C89E3B}> (#<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/LISP-ACTION:CL-SOURCE-FILE {6C9BEC4B}>) NIL)
;;  46: (#<FUNCTION {38045910}> (#<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/LISP-ACTION:CL-SOURCE-FILE {6C9BEC4B}>))
;;  47: (#<FUNCTION {6910BB84}> #<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/LISP-ACTION:CL-SOURCE-FILE {6C9BEC4B}>)
;;  48: (APPLY #<FUNCTION {6910BB84}> (#<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/LISP-ACTION:CL-SOURCE-FILE {6C9BEC4B}>))
;;  49: (#<FUNCTION {4F1F2B16}> (#<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/LISP-ACTION:CL-SOURCE-FILE {6C9BEC4B}>))
;;  50: (#<FUNCTION {39D05D88}> #<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/LISP-ACTION:CL-SOURCE-FILE {6C9BEC4B}>)
;;  51: (APPLY #<FUNCTION {39D05D88}> (#<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/LISP-ACTION:CL-SOURCE-FILE {6C9BEC4B}>))
;;  52: (ASDF/ACTION:PERFORM-WITH-RESTARTS #<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/LISP-ACTION:CL-SOURCE-FILE {6C9BEC4B}>)
;;  53: (#<FUNCTION {23865F7B}> ((#<ASDF/LISP-ACTION:COMPILE-OP {2425BC0B}> . #<ASDF/COMPONENT:MODULE {235583EB}>) (#<ASDF/LISP-ACTION:COMPILE-OP {2425BC0B}> . #<ASDF/COMPONENT:MODULE {177A09BC}>) (#<ASDF/LIS..
;;  54: (APPLY #<FUNCTION {23865F7B}> (((# . #) (# . #) (# . #) (# . #) (# . #) (# . #) ...)))
;;  55: (#<FUNCTION {4FA60C14}> (((# . #) (# . #) (# . #) (# . #) (# . #) (# . #) ...)))
;;  56: (JVM::%WITH-COMPILATION-UNIT #<FUNCTION {7957C96D}>)
;;  57: (#<FUNCTION {4250E7D2}> ((#<ASDF/LISP-ACTION:COMPILE-OP {2425BC0B}> . #<ASDF/COMPONENT:MODULE {235583EB}>) (#<ASDF/LISP-ACTION:COMPILE-OP {2425BC0B}> . #<ASDF/COMPONENT:MODULE {177A09BC}>) (#<ASDF/LIS..
;;  58: (APPLY #<FUNCTION {4250E7D2}> (((# . #) (# . #) (# . #) (# . #) (# . #) (# . #) ...)))
;;  59: (ASDF/PLAN:PERFORM-PLAN ((#<ASDF/LISP-ACTION:COMPILE-OP {2425BC0B}> . #<ASDF/COMPONENT:MODULE {235583EB}>) (#<ASDF/LISP-ACTION:COMPILE-OP {2425BC0B}> . #<ASDF/COMPONENT:MODULE {177A09BC}>) (#<ASDF/LIS..
;;  60: (APPLY ASDF/PLAN:PERFORM-PLAN ((#<ASDF/LISP-ACTION:COMPILE-OP {2425BC0B}> . #<ASDF/COMPONENT:MODULE {235583EB}>) (#<ASDF/LISP-ACTION:COMPILE-OP {2425BC0B}> . #<ASDF/COMPONENT:MODULE {177A09BC}>) (#<AS..
;;  61: (#<FUNCTION {533C1564}> #<ASDF/PLAN:SEQUENTIAL-PLAN {2C0575BB}>)
;;  62: (APPLY #<FUNCTION {533C1564}> (#<ASDF/PLAN:SEQUENTIAL-PLAN {2C0575BB}>))
;;  63: (#<FUNCTION {6BDEDDF7}> (#<ASDF/PLAN:SEQUENTIAL-PLAN {2C0575BB}>))
;;  64: (JVM::%WITH-COMPILATION-UNIT #<FUNCTION {2E75C929}>)
;;  65: (#<FUNCTION {1D517EB6}> #<ASDF/PLAN:SEQUENTIAL-PLAN {2C0575BB}>)
;;  66: (APPLY #<FUNCTION {1D517EB6}> (#<ASDF/PLAN:SEQUENTIAL-PLAN {2C0575BB}>))
;;  67: (ASDF/PLAN:PERFORM-PLAN #<ASDF/PLAN:SEQUENTIAL-PLAN {2C0575BB}>)
;;  68: (APPLY ASDF/PLAN:PERFORM-PLAN #<ASDF/PLAN:SEQUENTIAL-PLAN {2C0575BB}> NIL)
;;  69: (#<FUNCTION {1A7E780A}> #<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/INTERFACE::SYSTEM-CONNECTION {7D6B0925}>)
;;  70: (APPLY #<FUNCTION {1A7E780A}> (#<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/INTERFACE::SYSTEM-CONNECTION {7D6B0925}>))
;;  71: (#<FUNCTION {7D23FD7}> (#<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/INTERFACE::SYSTEM-CONNECTION {7D6B0925}>))
;;  72: (#<FUNCTION {7EE8285}>)
;;  73: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #<FUNCTION {7EE8285}>)
;;  74: (ASDF/FIND-SYSTEM::CALL-WITH-SYSTEM-DEFINITIONS #<FUNCTION {7EE8285}>)
;;  75: (#<FUNCTION {11DCE800}> #<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/INTERFACE::SYSTEM-CONNECTION {7D6B0925}>)
;;  76: (APPLY #<FUNCTION {11DCE800}> (#<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/INTERFACE::SYSTEM-CONNECTION {7D6B0925}>))
;;  77: (#<FUNCTION {780B6C19}> (#<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/INTERFACE::SYSTEM-CONNECTION {7D6B0925}>))
;;  78: (ASDF/OPERATE:OPERATE #<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/INTERFACE::SYSTEM-CONNECTION {7D6B0925}>)
;;  79: (APPLY ASDF/OPERATE:OPERATE #<ASDF/LISP-ACTION:LOAD-OP {2DD16CED}> #<ASDF/INTERFACE::SYSTEM-CONNECTION {7D6B0925}> NIL)
;;  80: (#<FUNCTION {6EB1D848}> ASDF/LISP-ACTION:LOAD-OP "containers-and-utilities")
;;  81: (APPLY #<FUNCTION {6EB1D848}> (ASDF/LISP-ACTION:LOAD-OP "containers-and-utilities"))
;;  82: (#<FUNCTION {1D3885B1}> (ASDF/LISP-ACTION:LOAD-OP "containers-and-utilities"))
;;  83: (#<FUNCTION {6BD2F2FE}>)
;;  84: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #<FUNCTION {6BD2F2FE}>)
;;  85: (ASDF/FIND-SYSTEM::CALL-WITH-SYSTEM-DEFINITIONS #<FUNCTION {6BD2F2FE}>)
;;  86: (#<FUNCTION {481A3039}> ASDF/LISP-ACTION:LOAD-OP "containers-and-utilities")
;;  87: (APPLY #<FUNCTION {481A3039}> (ASDF/LISP-ACTION:LOAD-OP "containers-and-utilities"))
;;  88: (ASDF/OPERATE:OPERATE ASDF/LISP-ACTION:LOAD-OP "containers-and-utilities")
;;  89: (APPLY ASDF/OPERATE:OPERATE ASDF/LISP-ACTION:LOAD-OP "containers-and-utilities" NIL)
;;  90: (ASDF/OPERATE:LOAD-SYSTEM "containers-and-utilities")
;;  91: (#<FUNCTION (LAMBDA (ASDF/INTERFACE::CONNECTION)) {2889C2EA}> #<ASDF/INTERFACE::SYSTEM-CONNECTION {7D6B0925}>)
;;  92: (MAPHASH #<FUNCTION {7145DF47}> #<EQUAL HASH-TABLE 9 entries, 22 buckets {DFC8693}>)
;;  93: (ASDF/INTERFACE:MAP-SYSTEM-CONNECTIONS #<FUNCTION (LAMBDA (ASDF/INTERFACE::CONNECTION)) {2889C2EA}>)
;;  94: (ASDF/INTERFACE::LOAD-CONNECTED-SYSTEMS)
;;  95: (#<FUNCTION {147EE4ED}> #<ASDF/LISP-ACTION:LOAD-OP {343B9A39}> #<ASDF/SYSTEM:SYSTEM {2C24064}> :VERBOSE NIL)
;;  96: (APPLY #<FUNCTION {147EE4ED}> (#<ASDF/LISP-ACTION:LOAD-OP {343B9A39}> #<ASDF/SYSTEM:SYSTEM {2C24064}> :VERBOSE NIL))
;;  97: (#<FUNCTION {7286EA1A}> (#<ASDF/LISP-ACTION:LOAD-OP {343B9A39}> #<ASDF/SYSTEM:SYSTEM {2C24064}> :VERBOSE NIL))
;;  98: (#<FUNCTION {2DE6BCEA}>)
;;  99: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #<FUNCTION {2DE6BCEA}>)
;;  100: (ASDF/FIND-SYSTEM::CALL-WITH-SYSTEM-DEFINITIONS #<FUNCTION {2DE6BCEA}>)
;;  101: (#<FUNCTION {44C77FDB}> #<ASDF/LISP-ACTION:LOAD-OP {343B9A39}> #<ASDF/SYSTEM:SYSTEM {2C24064}> :VERBOSE NIL)
;;  102: (APPLY #<FUNCTION {44C77FDB}> (#<ASDF/LISP-ACTION:LOAD-OP {343B9A39}> #<ASDF/SYSTEM:SYSTEM {2C24064}> :VERBOSE NIL))
;;  103: (ASDF/OPERATE:OPERATE #<ASDF/LISP-ACTION:LOAD-OP {343B9A39}> #<ASDF/SYSTEM:SYSTEM {2C24064}> :VERBOSE NIL)
;;  104: (APPLY ASDF/OPERATE:OPERATE #<ASDF/LISP-ACTION:LOAD-OP {343B9A39}> #<ASDF/SYSTEM:SYSTEM {2C24064}> (:VERBOSE NIL))
;;  105: (#<FUNCTION {6EB1D848}> ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL)
;;  106: (APPLY #<FUNCTION {6EB1D848}> (ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL))
;;  107: (#<FUNCTION {1D3885B1}> (ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL))
;;  108: (#<FUNCTION {277DA222}>)
;;  109: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #<FUNCTION {277DA222}>)
;;  110: (ASDF/FIND-SYSTEM::CALL-WITH-SYSTEM-DEFINITIONS #<FUNCTION {277DA222}>)
;;  111: (#<FUNCTION {62EE5AED}> ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL)
;;  112: (APPLY #<FUNCTION {62EE5AED}> (ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL))
;;  113: (ASDF/OPERATE:OPERATE ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL)
;;  114: (APPLY ASDF/OPERATE:OPERATE ASDF/LISP-ACTION:LOAD-OP "cl-containers" (:VERBOSE NIL))
;;  115: (#<FUNCTION {7A77ABB6}> ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL)
;;  116: (APPLY #<FUNCTION {7A77ABB6}> (ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL))
;;  117: (#<FUNCTION {5313A84}> (ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL))
;;  118: (ASDF/OPERATE:OPERATE ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL)
;;  119: (APPLY ASDF/OPERATE:OPERATE ASDF/LISP-ACTION:LOAD-OP "cl-containers" (:VERBOSE NIL))
;;  120: (ASDF/OPERATE:OOS ASDF/LISP-ACTION:LOAD-OP "cl-containers" :VERBOSE NIL)
;;  121: (#<FUNCTION {4F17E4B2}>)
;;  122: (QUICKLISP-CLIENT::CALL-WITH-MACROEXPAND-PROGRESS #<FUNCTION {4F17E4B2}>)
;;  123: (QUICKLISP-CLIENT::APPLY-LOAD-STRATEGY #<QUICKLISP-CLIENT::LOAD-STRATEGY {5FBEE68F}>)
;;  124: (QUICKLISP-CLIENT::AUTOLOAD-SYSTEM-AND-DEPENDENCIES :CL-CONTAINERS :PROMPT NIL)
;;  125: (#<FUNCTION {1853CCD5}>)
;;  126: (#<FUNCTION {143A3041}> (#<QL-IMPL:ABCL {64F86400}> #<FUNCTION {1853CCD5}>))
;;  127: (QL-IMPL-UTIL::%CALL-WITH-QUIET-COMPILATION #<QL-IMPL:ABCL {64F86400}> #<FUNCTION {1853CCD5}>)
;;  128: (QL-IMPL-UTIL:CALL-WITH-QUIET-COMPILATION #<FUNCTION {1853CCD5}>)
;;  129: (#<FUNCTION {4C5A7C8E}> :CL-CONTAINERS)
;;  130: (APPLY #<FUNCTION {4C5A7C8E}> (:CL-CONTAINERS))
;;  131: (#<FUNCTION {4AE924B4}> (:CL-CONTAINERS))
;;  132: (#<FUNCTION {F14BD90}>)
;;  133: (QL-DIST::CALL-WITH-CONSISTENT-DISTS #<FUNCTION {F14BD90}>)
;;  134: (#<FUNCTION {286B1016}> :CL-CONTAINERS)
;;  135: (APPLY #<FUNCTION {286B1016}> (:CL-CONTAINERS))
;;  136: (#<FUNCTION {374AA799}> (:CL-CONTAINERS))
;;  137: (#<STANDARD-GENERIC-FUNCTION {2EB7550E}> :CL-CONTAINERS)
;;  138: (SYSTEM::%EVAL (QUICKLISP-CLIENT:QUICKLOAD :CL-CONTAINERS))
;;  139: (EVAL (QUICKLISP-CLIENT:QUICKLOAD :CL-CONTAINERS))
;;  140: (#<FUNCTION {1ED73A6D}>)
;;  141: (SWANK::CALL-WITH-RETRY-RESTART "Retry SLIME interactive evaluation request." #<FUNCTION {1ED73A6D}>)
;;  142: (#<FUNCTION {6E4C7201}>)
;;  143: (FUNCALL #<FUNCTION {6E4C7201}>)
;;  144: (#<FUNCTION (LAMBDA (SWANK-BACKEND::FN)) {CD8663E}> #<FUNCTION {6E4C7201}>)
;;  145: (APPLY #<FUNCTION (LAMBDA (SWANK-BACKEND::FN)) {CD8663E}> #<FUNCTION {6E4C7201}> NIL)
;;  146: (SWANK-BACKEND:CALL-WITH-SYNTAX-HOOKS #<FUNCTION {6E4C7201}>)
;;  147: (SWANK::CALL-WITH-BUFFER-SYNTAX NIL #<FUNCTION {6E4C7201}>)
;;  148: (SWANK:INTERACTIVE-EVAL "(ql:quickload :cl-containers)")
;;  149: (SYSTEM::%EVAL (SWANK:INTERACTIVE-EVAL "(ql:quickload :cl-containers)"))
;;  150: (EVAL (SWANK:INTERACTIVE-EVAL "(ql:quickload :cl-containers)"))
;;  151: (SWANK:EVAL-FOR-EMACS (SWANK:INTERACTIVE-EVAL "(ql:quickload :cl-containers)") "COMMON-LISP-USER" 13)
;;  152: (APPLY #<EVAL-FOR-EMACS {5D84C6F8}> ((SWANK:INTERACTIVE-EVAL "(ql:quickload :cl-containers)") "COMMON-LISP-USER" 13))
;;  153: (#<FUNCTION {170C411C}>)
;;  154: (FUNCALL #<FUNCTION {170C411C}>)
;;  155: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK) #<SWANK-DEBUGGER-HOOK {2160941E}> #<FUNCTION {170C411C}>)
;;  156: (APPLY #<(FLET CALL-WITH-DEBUGGER-HOOK) {30AF05C2}> #<SWANK-DEBUGGER-HOOK {2160941E}> #<FUNCTION {170C411C}> NIL)
;;  157: (SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK #<SWANK-DEBUGGER-HOOK {2160941E}> #<FUNCTION {170C411C}>)
;;  158: (#<FUNCTION {3D7EA5AC}>)
;;  159: (SWANK::CALL-WITH-BINDINGS ((*STANDARD-OUTPUT* . #S(SLIME-OUTPUT-STREAM)) (*STANDARD-INPUT* . #S(SLIME-INPUT-STREAM)) (*TRACE-OUTPUT* . #S(SLIME-OUTPUT-STREAM)) (*ERROR-OUTPUT* . #S(SLIME-OUTPUT-STREA..
;;  160: (#<FUNCTION {729764D}>)
;;  161: (SWANK::CALL-WITH-BINDINGS NIL #<FUNCTION {729764D}>)
;;  162: (#<FUNCTION {4FE0F27F}>)
;;  163: (FUNCALL #<FUNCTION {4FE0F27F}>)
;;  164: (#<FUNCTION (LAMBDA ()) {77B7DEA}>)
;;  165: (THREADS::THREAD-FUNCTION-WRAPPER #<FUNCTION (LAMBDA ()) {77B7DEA}>)

[fare]

This certainly makes more sense. It looks like ABCL gets confused about the package in which those symbols reside.

What if you modify utilities-integration.lisp to use (in-package :containers) then explicitly prefix export-exported-symbols and make-load-form* with metatilities: ?

[fare]

Did you open a bug request against ABCL?

[pnathan]

The suggested modification works (that is to say, it fasl-loads). Exploratory testing with the heap and the red-black tree indicates that it does not break functionality.

diff --git a/dev/utilities-integration.lisp b/dev/utilities-integration.lisp
index 451b941..265ad18 100644
--- a/dev/utilities-integration.lisp
+++ b/dev/utilities-integration.lisp
@@ -1,9 +1,7 @@
-(in-package #:metatilities)
+(in-package #:containers)

 (eval-when (:compile-toplevel)
-  (export-exported-symbols '#:cl-containers '#:metatilities))
-
-(make-load-form* containers:abstract-container)
-(make-load-form* containers:container-node-mixin)
-
+  (metatilities:export-exported-symbols '#:cl-containers '#:metatilities))

+(metatilities:make-load-form* containers:abstract-container)
+(metatilities:make-load-form* containers:container-node-mixin)

[pnathan]

No, I'm not even sure what to tell ABCL yet besides, "Derp, there's a broken. Maybe some sort of FASL thing with symbols, packages, and make-load-saving-form?" I'll take a swing at rummaging through the ABCL source later today and see what I come up with. That cl-container doesn't load is known to ABCL devs at present though, per my initial issue filing up-thread.

[fare]

It looks like their make-load-form might involve printing symbols in one package context and reading them in another; but who am I to tell?

So yes, give them some explanation, steps to reproduce, proposed fixes, and link to this page.

[pnathan]

Ticket logged here http://abcl.org/trac/ticket/357.

[gwkkwg]

Hi Faré and Paul,

Thanks for bringing this up and tracking it down. It does look like an ABCL thing to me (but I certainly haven't delved deeply!).

AFAICT, you (Paul) have a work-around and hopefully ABCL will chime in as to whether the package analysis is the root cause.

thanks again,