Using ReadList with Throw

Question

I'm using ReadList to pull the declarations off of a package like so:

PackagePullDeclarationsAction // Clear
PackagePullDeclarationsAction[
   Hold[
    _Begin | _BeginPackage |
     CompoundExpression[_Begin | _BeginPackage, ___]
    ]
   ] :=
  Throw[Begin];
PackagePullDeclarationsAction[e : Except[Hold[Expression]]] :=
  Sow@e;

PackagePullHeader[pkgFile_] :=
 Reap[
   Catch@
    ReadList[pkgFile,
     PackagePullDeclarationsAction@Hold[Expression]
     ]
   ][[2, 1]]

The PackagePullDeclarationsAction either uses Sow to sow an expression or Throw to abort the ReadList call. And this works as intended:

$pkgFile =
  URLDownload[
   "https://raw.githubusercontent.com/b3m2a1/mathematica-BTools/\
master/Packages/AppBuilder.m",
   FileNameJoin@{$TemporaryDirectory, "AppBuilder.m"}
   ];

Begin["test`"];
Take[
 PackagePullHeader[$pkgFile] // DeleteCases[Hold[Null]],
 5
 ]
End[];

{Hold[$AppDirectoryRoot::usage = 
    "The directory root for finding apps";], 
 Hold[$AppDirectoryName::usage = 
    "The basic extension to a directory for locating apps";], 
 Hold[$AppDirectory::usage = "Joins the root and name";], 
 Hold[AppPath::usage = "A path parser for a given app name";], 
 Hold[AppDirectory::usage = 
    "Used by AppPath find appropriate directories";]}

The problem is that it also loaded all of my "`Private`" symbols into the primary Context:

Names["test`*"]~Take~5

{"test`a", "test`add", "test`app", "test`AppAddContent", \
"test`AppAddDocPage"}

What's going on here? ReadList clearly didn't ignore the Throw so did it load everything first then apply PackagePullDeclarationsAction?

Is there a good work-around for this? Am I just missing something trivial?

Answer 1

Simple order of operations.

ReadList[expr, f["Expression"]]

constructs the list {f[e1], f[e2], ...} for each expression in expr. Then that will evaluate, or not, depending on what f is. However, every expression in expr has already been created. And since the BeginPackage never evaluated, all symbols without a known context will end up in the current context.

This is a general feature of reading package files. You'd encounter a similar issue with Import["foo.m", "HeldExpressions"]. Because the context can change dynamically, each expression must be read and evaluated sequentially to guarantee the expression. Your only alternative would be to write packages which fully qualify every single symbol in them so there's never a context issue.

Answer 2

Maybe you can do something like:

Begin["test`"];
Block[{BeginPackage=Identity,Begin=Throw},
    Catch@Get[package]
];
End[]

For your example:

$pkgFile = URLDownload[
    "https://raw.githubusercontent.com/b3m2a1/mathematica-BTools/master/Packages/AppBuilder.m",
    FileNameJoin@{$TemporaryDirectory, "AppBuilder.m"}
];

Begin["test`"];
Block[{BeginPackage=Identity, Begin=Throw},
    Catch @ Get[$pkgFile]
];
End[];

#->MessageName[#, "usage"]& /@ Symbol /@ Names["test`*"][[;;5]]

{test`AppAddContent -> "Adds a file to the app", test`AppAddDocPage -> "Adds a doc page for a symbol to the app", test`AppAddGuidePage -> "Adds a guide to the app", test`AppAddPackage -> "Adds a package", test`AppAddPalette -> "Adds a palette to the app"}