more changes for scoped export -> public

base/exports.jl

@@ -1065,70 +1065,70 @@ export
  @static
 
 #=
-export (scoped-true)
+public
  @assume_effects,
  @constprop,
  @locals,
  @propagate_inbounds,
- :AbstractLock,
- :AsyncCondition,
- :CFunction,
- :Checked,
- :CodeUnits,
- :DL_LOAD_PATH,
- :EnvDict,
- :Event,
- :Fix1,
- :Fix2,
- :Generator,
- :ImmutableDict,
- :IteratorEltype,
- :IteratorSize,
- :OneTo,
- :Pairs,
- :Semaphore,
- :UUID,
- :acquire,
- :active_project,
- :add_sum,
- :cconvert,
- :checked_length,
- :compilecache,
- :datatype_alignment,
- :datatype_haspadding,
- :datatype_pointerfree,
- :elsize,
- :exit_on_sigint,
- :front,
- :identify_package,
- :include,
- :isambiguous,
- :isbinaryoperator,
- :isdone,
- :isexpr,
- :isidentifier,
- :isoperator,
- :issingletontype,
- :isunaryoperator,
- :jit_total_bytes,
- :load_path,
- :locate_package,
- :moduleroot,
- :notnothing,
- :operator_associativity,
- :operator_precedence,
- :promote_typejoin,
- :release,
- :require,
- :rest,
- :runtests,
- :set_active_project,
- :split_rest,
- :summarysize,
- :tail,
- :text_colors,
- :to_index,
- :unsafe_convert,
- :vect,
- :windowserror
+ AbstractLock,
+ AsyncCondition,
+ CFunction,
+ Checked,
+ CodeUnits,
+ DL_LOAD_PATH,
+ EnvDict,
+ Event,
+ Fix1,
+ Fix2,
+ Generator,
+ ImmutableDict,
+ IteratorEltype,
+ IteratorSize,
+ OneTo,
+ Pairs,
+ Semaphore,
+ UUID,
+ acquire,
+ active_project,
+ add_sum,
+ cconvert,
+ checked_length,
+ compilecache,
+ datatype_alignment,
+ datatype_haspadding,
+ datatype_pointerfree,
+ elsize,
+ exit_on_sigint,
+ front,
+ identify_package,
+ include,
+ isambiguous,
+ isbinaryoperator,
+ isdone,
+ isexpr,
+ isidentifier,
+ isoperator,
+ issingletontype,
+ isunaryoperator,
+ jit_total_bytes,
+ load_path,
+ locate_package,
+ moduleroot,
+ notnothing,
+ operator_associativity,
+ operator_precedence,
+ promote_typejoin,
+ release,
+ require,
+ rest,
+ runtests,
+ set_active_project,
+ split_rest,
+ summarysize,
+ tail,
+ text_colors,
+ to_index,
+ unsafe_convert,
+ vect,
+ windowserror
 =#

base/reflection.jl

@@ -73,26 +73,28 @@ function fullname(m::Module)
 end
 
 """
- names(x::Module; all::Bool = false, imported::Bool = false)
+ names(x::Module; qualified::Bool=true, all::Bool = false, imported::Bool = false)
 
-Get an array of the names exported by a `Module`, excluding deprecated names.
-If `all` is true, then the list also includes non-exported names defined in the module,
+Get an array of the public names of `Module`, excluding deprecated names.
+
+If `qualified` is false, then return only exported names, not public but unexported names.
+If `all` is true, then the list also includes private names defined in the module,
 deprecated names, and compiler-generated names.
 If `imported` is true, then names explicitly imported from other modules
 are also included.
 
-As a special case, all names defined in `Main` are considered \"exported\",
-since it is not idiomatic to explicitly export names from `Main`.
+As a special case, all names defined in `Main` are considered \"public\",
+since it is not idiomatic to mark names from `Main` as public.
 
 See also: [`@locals`](@ref Base.@locals), [`@__MODULE__`](@ref).
 """
-names(m::Module; all::Bool = false, imported::Bool = false, scoped::Bool = true) =
- sort!(unsorted_names(m; all, imported, scoped))
-unsorted_names(m::Module; all::Bool = false, imported::Bool = false, scoped::Bool = true) =
- ccall(:jl_module_names, Array{Symbol,1}, (Any, Cint, Cint, Cint), m, all, imported, scoped)
+names(m::Module; qualified::Bool = true, all::Bool = false, imported::Bool = false) =
+ sort!(unsorted_names(m; qualified, all, imported))
+unsorted_names(m::Module; qualified::Bool = true, all::Bool = false, imported::Bool = false) =
+ ccall(:jl_module_names, Array{Symbol,1}, (Any, Cint, Cint, Cint), m, qualified, all, imported)
 
 isexported(m::Module, s::Symbol) = ccall(:jl_module_exports_p, Cint, (Any, Any), m, s) != 0
-isinternal(m::Module, s::Symbol) = !isexported(m, s) && ccall(:jl_module_scoped_exports_p, Cint, (Any, Any), m, s) == 0
+isinternal(m::Module, s::Symbol) = ccall(:jl_module_public_p, Cint, (Any, Any), m, s) == 0
 isdeprecated(m::Module, s::Symbol) = ccall(:jl_is_binding_deprecated, Cint, (Any, Any), m, s) != 0
 isbindingresolved(m::Module, var::Symbol) = ccall(:jl_binding_resolved_p, Cint, (Any, Any), m, var) != 0
 

base/show.jl

@@ -2232,7 +2232,7 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int, quote_level::In
  print(io, head, ' ')
  show_list(io, args, ", ", indent, 0, quote_level)
 
- elseif head === :export
+ elseif head in (:export, :public)
  print(io, head, ' ')
  show_list(io, mapany(allow_macroname, args), ", ", indent)
 

doc/src/manual/faq.md

@@ -23,32 +23,36 @@ On the other hand, language *interoperability* is extremely useful: we want to e
 ### How does Julia define its public API?
 
 Julia's public [API](https://en.wikipedia.org/wiki/API) is the behavior described in
-documentation of symbols exported from `Base`
-and the standard libraries. Functions, types, and constants are not part of the public
-API if they are not exported, _even if they have docstrings_. Further, only the documented
-behavior of exported symbols is part of the public API. Undocumented behavior of exported
+documentation of public symbols from `Base` and the standard libraries. Functions,
+types, and constants are not part of the public API if they are not public, even if
+they have docstrings or are described in the documentation. Further, only the documented
+behavior of public symbols is part of the public API. Undocumented behavior of public
 symbols is internal.
 
+Public symbols are those marked with either `public foo` or `export bar`.
+Exported symbols are automatically considered public
+
 In other words:
 
-- Documented behavior of exported symbols is part of the public API.
+- Documented behavior of public symbols is part of the public API.
 
-- Undocumented behavior of exported symbols is not part of the public API.
+- Undocumented behavior of public symbols is not part of the public API.
 
-- Documented behavior of unexported symbols is not part of the public API.
+- Documented behavior of private symbols is not part of the public API.
 
-- Undocumented behavior of unexported symbols is not part of the public API.
+- Undocumented behavior of private symbols is not part of the public API.
 
-You can get a complete list of the symbols exported from a module with `names(MyModule)`.
+You can get a complete list of the public symbols from a module with `names(MyModule)`.
 
 Package authors are encouraged to define their public API similarly.
 
-Documented behavior of symbols exported from submodules are only part of the public API
-if the module they belong to is also exported. If module A marks submodule B as public and
+Publicity nests in the same wa as exporting.
+Documented behavior of public symbols from submodules are only part of the public API
+if the module they belong to is also public. If module A marks submodule B as public and
 B marks foo as public, then A.B.foo is public, but if A does not mark B as public,
 then writing A.B.foo outside of A is accessing an internal and anything that B marks as
 public forms a sub-api that is not covered by the SymVer of A. This could be for the
-convenience of developers of A if A is a large package...
+convenience of developers of A if A is a large package.
 
 Anything in Julia's Public API is covered by [SemVer](https://semver.org/) and therefore
 will not be removed or receive meaningful breaking changes in a minor version update.

doc/src/manual/modules.md

@@ -78,10 +78,8 @@ module-local.
 ### Export lists
 
 Names (referring to functions, types, global variables, and constants) can be added to the
-*export list* of a module with `export`: these are the symbols that define the public API of
-the module and, by default, they are imported when `using` the module. Typically, they are
-at or near the top of the module definition so that readers of the source code can find them
-easily, as in
+*export list* of a module with `export`: these are the symbols that are imported when `using` the module. Typically, they are at or near the top of the module definition
+so that readers of the source code can find them easily, as in
 
 ```jldoctest module_manual
 julia> module NiceStuff
@@ -96,26 +94,23 @@ julia> module NiceStuff
 but this is just a style suggestion — a module can have multiple `export` statements in arbitrary
 locations.
 
-### Scoped Exports
+It is common to export names which form part of the API (application programming interface). In
+the above code, the export list suggests that users should use `nice` and `DOG`. However, since
+qualified names always make identifiers accessible, this is just an option for organizing APIs:
+unlike other languages, Julia has no facilities for truly hiding module internals.
 
-Modules should export all names which form part of their API, however it is sometimes
-unhelpful to automatically load every symbol that is part of the API on `using`. In this
-case, it is appropriate to use `export (scoped-true), name` instead of ``export name` to
-mark the symbol as a part of the public API, but not to load it on `using`. This is usually
-done when modules use common words, such as `derivative`, in their API, which could easily
-clash with the export lists of other modules. We will see how to manage name clashes below.
-
-Since qualified names always make identifiers accessible, this is just an option for
-organizing APIs: unlike some other languages, Julia discourages truly hiding module internals.
+Also, some modules don't export names at all. This is usually done if they use common
+words, such as `derivative`, in their API, which could easily clash with the export lists of other
+modules. We will see how to manage name clashes below.
 
 ### Standalone `using` and `import`
 
-The most common way of loading a module is `using ModuleName`. This [loads](@ref
+Possibly the most common way of loading a module is `using ModuleName`. This [loads](@ref
 code-loading) the code associated with `ModuleName`, and brings
 
 1. the module name
 
-2. and the elements of the export list (excluding scoped exports) into the surrounding global namespace.
+2. and the elements of the export list into the surrounding global namespace.
 
 Technically, the statement `using ModuleName` means that a module called `ModuleName` will be
 available for resolving names as needed. When a global variable is encountered that has no

src/ast.c

@@ -28,6 +28,7 @@ JL_DLLEXPORT jl_sym_t *jl_top_sym;
 JL_DLLEXPORT jl_sym_t *jl_module_sym;
 JL_DLLEXPORT jl_sym_t *jl_slot_sym;
 JL_DLLEXPORT jl_sym_t *jl_export_sym;
+JL_DLLEXPORT jl_sym_t *jl_public_sym;
 JL_DLLEXPORT jl_sym_t *jl_import_sym;
 JL_DLLEXPORT jl_sym_t *jl_toplevel_sym;
 JL_DLLEXPORT jl_sym_t *jl_quote_sym;
@@ -304,6 +305,7 @@ void jl_init_common_symbols(void)
  jl_lambda_sym = jl_symbol("lambda");
  jl_module_sym = jl_symbol("module");
  jl_export_sym = jl_symbol("export");
+ jl_public_sym = jl_symbol("public");
  jl_import_sym = jl_symbol("import");
  jl_using_sym = jl_symbol("using");
  jl_assign_sym = jl_symbol("=");

src/builtins.c

@@ -1929,7 +1929,7 @@ static void add_intrinsic(jl_module_t *inm, const char *name, enum intrinsic f)
  jl_value_t *i = jl_permbox32(jl_intrinsic_type, 0, (int32_t)f);
  jl_sym_t *sym = jl_symbol(name);
  jl_set_const(inm, sym, i);
- jl_module_export(inm, sym, 0);
+ jl_module_public(inm, sym, 1);
 }
 
 void jl_init_intrinsic_properties(void) JL_GC_DISABLED

src/jl_exported_funcs.inc

@@ -325,14 +325,14 @@
  XX(jl_methtable_lookup) \
  XX(jl_mi_cache_insert) \
  XX(jl_module_build_id) \
- XX(jl_module_export) \
  XX(jl_module_exports_p) \
  XX(jl_module_globalref) \
  XX(jl_module_import) \
  XX(jl_module_name) \
  XX(jl_module_names) \
  XX(jl_module_parent) \
- XX(jl_module_scoped_exports_p) \
+ XX(jl_module_public) \
+ XX(jl_module_public_p) \
  XX(jl_module_use) \
  XX(jl_module_using) \
  XX(jl_module_usings) \

src/julia-parser.scm

@@ -1617,8 +1617,8 @@
  ((export)
  (let ((es (map macrocall-to-atsym
  (parse-comma-separated s parse-unary-prefix))))
- ; (if (not (every symbol-or-interpolate? es)) ; TODO make this much more strict
- ;  (error "invalid \"export\" statement"))
+ (if (not (every symbol-or-interpolate? es))
+ (error "invalid \"export\" statement"))
  `(export ,@es)))
  ((import using)
  (parse-imports s word))

src/julia.h

@@ -594,8 +594,8 @@ typedef struct _jl_binding_t {
  _Atomic(struct _jl_binding_t*) owner; // for individual imported bindings (NULL until 'resolved')
  _Atomic(jl_value_t*) ty; // binding type
  uint8_t constp:1;
- uint8_t exportp:1;
- uint8_t scoped_exportp:1; // `scoped export foo` sets both `exportp` and `scoped_exportp`.
+ uint8_t exportp:1; // `public foo` sets `publicp`, `export foo` sets both `publicp` and `exportp`
+ uint8_t publicp:1; // exportp without publicp is not allowed.
  uint8_t imported:1;
  uint8_t usingfailed:1;
  uint8_t deprecated:2; // 0=not deprecated, 1=renamed, 2=moved to another package
@@ -1737,7 +1737,7 @@ JL_DLLEXPORT void jl_module_use(jl_module_t *to, jl_module_t *from, jl_sym_t *s)
 JL_DLLEXPORT void jl_module_use_as(jl_module_t *to, jl_module_t *from, jl_sym_t *s, jl_sym_t *asname);
 JL_DLLEXPORT void jl_module_import(jl_module_t *to, jl_module_t *from, jl_sym_t *s);
 JL_DLLEXPORT void jl_module_import_as(jl_module_t *to, jl_module_t *from, jl_sym_t *s, jl_sym_t *asname);
-JL_DLLEXPORT void jl_module_export(jl_module_t *from, jl_sym_t *s, int scoped);
+JL_DLLEXPORT void jl_module_public(jl_module_t *from, jl_sym_t *s, int exp);
 JL_DLLEXPORT int jl_is_imported(jl_module_t *m, jl_sym_t *s);
 JL_DLLEXPORT int jl_module_exports_p(jl_module_t *m, jl_sym_t *var);
 JL_DLLEXPORT void jl_add_standard_imports(jl_module_t *m);

src/julia_internal.h

@@ -1498,6 +1498,7 @@ extern JL_DLLEXPORT jl_sym_t *jl_top_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_module_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_slot_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_export_sym;
+extern JL_DLLEXPORT jl_sym_t *jl_public_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_import_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_toplevel_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_quote_sym;