Atom constructors can be private

CHANGELOG.md

@@ -1127,6 +1127,7 @@
 - [Autoscoped constructors][9190]
 - [Allow Oracle GraalVM JDK][9322]
 - [`Table.join` can access its `right` argument][9410]
+- [Atom constructors can be project-private][9692]
 
 [3227]: https://github.com/enso-org/enso/pull/3227
 [3248]: https://github.com/enso-org/enso/pull/3248
@@ -1287,6 +1288,7 @@
 [8867]: https://github.com/enso-org/enso/pull/8867
 [9190]: https://github.com/enso-org/enso/pull/9190
 [9322]: https://github.com/enso-org/enso/pull/9322
+[9692]: https://github.com/enso-org/enso/pull/9692
 [9410]: https://github.com/enso-org/enso/pull/9410
 
 # Enso 2.0.0-alpha.18 (2021-10-12)

distribution/lib/Standard/Base/0.0.0-dev/src/Errors/Common.enso

@@ -307,6 +307,32 @@ type Not_Invokable
     to_display_text : Text
     to_display_text self = "Type error: expected a function, but got "+self.target.to_display_text+"."
 
+@Builtin_Type
+type Private_Access
+    ## PRIVATE
+       An error that occurs when a private (project-private) method is called from a different
+       project.
+
+       Arguments:
+       - this_project_name: Optional qualified name of the current (caller) project.
+       - target_project_name: Optional qualified name name of the project of callee.
+       - target_method_name: The name of the target method call that is project-private and thus cannot be called.
+    Error (this_project_name : (Text | Nothing)) (target_project_name : (Text | Nothing)) (target_method_name : Text)
+
+    ## PRIVATE
+       Convert the Private_Access error to a human-readable format.
+    to_display_text : Text
+    to_display_text self =
+        this_proj = if self.this_project_name.is_nothing then "unknown project" else "project '"+self.this_project_name+"'"
+        target_proj = if self.target_project_name.is_nothing then "unknown project" else "project '"+self.target_project_name+"'"
+        "Private access error: The project-private method '"
+            + self.target_method_name
+            + "' in "
+            + target_proj
+            + " cannot be accessed from "
+            + this_proj
+            + "."
+
 @Builtin_Type
 type Unsupported_Argument_Types
     ## PRIVATE

docs/semantics/encapsulation.md

@@ -78,6 +78,10 @@ Methods on types (or on modules) can be specified private. To check whether a
 private method is accessed only from within the same project, a runtime check
 must be performed, as this cannot be checked during the compilation.
 
+### Polyglot access
+No polyglot foreign code can access private entities. For all the foreign code,
+private entities are not visible.
+
 ## Example
 
 Lib/src/Pub_Type.enso:
@@ -87,8 +91,6 @@ type Pub_Type
   Constructor field
   private priv_method self = ...
   pub_method self = self.field.to_text
-
-private type Priv_Type
 ```
 
 Lib/src/Methods.enso:
@@ -104,26 +106,21 @@ Lib/src/Internal/Helpers.enso:
 # Mark the whole module as private
 private
 
-# OK to import private types in the same project
-import project.Pub_Type.Priv_Type
 ```
 
 Lib/src/Main.enso:
 
 ```
 import project.Pub_Type.Pub_Type
 export project.Pub_Type.Pub_Type
-
-import project.Pub_Type.Priv_Type # OK - we can import private types in the same project.
-export project.Pub_Type.Priv_Type # Failes at compile time - re-exporting private types is forbidden.
 ```
 
 tmp.enso:
 
 ```
 from Lib import Pub_Type
-import Lib.Pub_Type.Priv_Type # Fails during compilation
 import Lib.Methods
+import Lib.Internal.Helpers # Fails during compilation - cannot import private module
 
 main =
   # This constructor is not private, we can use it here.
@@ -133,8 +130,6 @@ main =
   Pub_Type.priv_method self=obj # Runtime failure
   obj.pub_method # OK
 
-  Lib.Pub_Type.Priv_Type # Fails at runtime - accessing private types via FQN is forbidden
-
   Methods.pub_stat_method 1 2 # OK
   Methods.priv_stat_method # Fails at runtime
 ```

engine/polyglot-api/src/main/scala/org/enso/polyglot/Function.scala

@@ -16,6 +16,9 @@ class Function(val value: Value) {
     */
   def execute(args: AnyRef*): Value = value.execute(args: _*)
 
+  /** Helper method for java that just delegates to the other execute method */
+  def execute(): Value = value.execute()
+
   /** Checks function equality by checking the identity of the underlying
     * objects.
     *

engine/runtime-compiler/src/main/java/org/enso/compiler/dump/GraphVizNode.java

@@ -9,6 +9,8 @@
 import java.util.stream.Collectors;
 import org.enso.compiler.core.IR;
 import org.enso.compiler.core.ir.MetadataStorage;
+import org.enso.compiler.pass.IRPass.IRMetadata;
+import org.enso.compiler.pass.resolve.DocumentationComments;
 
 /**
  * Represents a node in the GraphViz graph.
@@ -84,6 +86,9 @@ static class Builder {
     private Map<String, String> additionalAttrs = new HashMap<>();
     private Object object;
 
+    private static final List<Class<? extends IRMetadata>> metadataToSkip =
+        List.of(DocumentationComments.Doc.class);
+
     static Builder fromObject(Object obj) {
       var className = className(obj);
       var id = Utils.id(obj);
@@ -129,8 +134,10 @@ static Builder fromIr(IR ir) {
         ir.passData()
             .map(
                 (pass, metadata) -> {
-                  var metaName = metadata.metadataName();
-                  bldr.addLabelLine("  - " + metaName);
+                  if (!metadataToSkip.contains(metadata.getClass())) {
+                    var metaName = metadata.metadataName();
+                    bldr.addLabelLine("  - " + metaName);
+                  }
                   return null;
                 });
       } else {

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/analyse/PrivateConstructorAnalysis.java

@@ -0,0 +1,91 @@
+package org.enso.compiler.pass.analyse;
+
+import java.util.List;
+import java.util.UUID;
+import org.enso.compiler.context.InlineContext;
+import org.enso.compiler.context.ModuleContext;
+import org.enso.compiler.core.IR;
+import org.enso.compiler.core.ir.Expression;
+import org.enso.compiler.core.ir.Module;
+import org.enso.compiler.core.ir.expression.errors.Syntax;
+import org.enso.compiler.core.ir.expression.errors.Syntax.InconsistentConstructorVisibility$;
+import org.enso.compiler.core.ir.module.scope.Definition;
+import org.enso.compiler.pass.IRPass;
+import scala.collection.immutable.Seq;
+import scala.jdk.javaapi.CollectionConverters;
+
+/**
+ * Ensures that all type definitions have either all constructors public, or all constructors
+ * private.
+ */
+public final class PrivateConstructorAnalysis implements IRPass {
+  public static final PrivateConstructorAnalysis INSTANCE = new PrivateConstructorAnalysis();
+
+  private UUID uuid;
+
+  private PrivateConstructorAnalysis() {}
+
+  @Override
+  public void org$enso$compiler$pass$IRPass$_setter_$key_$eq(UUID v) {
+    this.uuid = v;
+  }
+
+  @Override
+  public UUID key() {
+    return uuid;
+  }
+
+  @Override
+  public Seq<IRPass> precursorPasses() {
+    List<IRPass> passes = List.of(PrivateModuleAnalysis.INSTANCE);
+    return CollectionConverters.asScala(passes).toList();
+  }
+
+  @Override
+  public Seq<IRPass> invalidatedPasses() {
+    Object obj = scala.collection.immutable.Nil$.MODULE$;
+    return (scala.collection.immutable.List<IRPass>) obj;
+  }
+
+  @Override
+  public Module runModule(Module ir, ModuleContext moduleContext) {
+    var newBindings =
+        ir.bindings()
+            .map(
+                binding -> {
+                  if (binding instanceof Definition.Type type) {
+                    var privateCtorsCnt = type.members().filter(ctor -> ctor.isPrivate()).size();
+                    var publicCtorsCnt = type.members().filter(ctor -> !ctor.isPrivate()).size();
+                    var ctorsCnt = type.members().size();
+                    if (!(privateCtorsCnt == ctorsCnt || publicCtorsCnt == ctorsCnt)) {
+                      assert type.location().isDefined();
+                      return Syntax.apply(
+                          type.location().get(),
+                          InconsistentConstructorVisibility$.MODULE$,
+                          type.passData(),
+                          type.diagnostics());
+                    }
+                  }
+                  return binding;
+                });
+    return ir.copy(
+        ir.imports(),
+        ir.exports(),
+        newBindings,
+        ir.location(),
+        ir.passData(),
+        ir.diagnostics(),
+        ir.id());
+  }
+
+  /** Not supported on a single expression. */
+  @Override
+  public Expression runExpression(Expression ir, InlineContext inlineContext) {
+    return ir;
+  }
+
+  @Override
+  public <T extends IR> T updateMetadataInDuplicate(T sourceIr, T copyOfIr) {
+    return IRPass.super.updateMetadataInDuplicate(sourceIr, copyOfIr);
+  }
+}