Show only fields from current atom constructor in the debugger

engine/runtime-integration-tests/src/test/java/org/enso/interpreter/test/AtomInteropTest.java

@@ -2,14 +2,19 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.hasItem;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
 import static org.hamcrest.Matchers.notNullValue;
 
+import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.interop.InvalidArrayIndexException;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import org.enso.test.utils.ContextUtils;
 import org.graalvm.polyglot.Context;
 import org.junit.After;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 
 /**
@@ -90,7 +95,6 @@ public void typeHasAnyAsSuperType() {
     assertThat(anyType.getMetaSimpleName(), is("Any"));
   }
 
-  @Ignore("https://github.com/enso-org/enso/issues/10675")
   @Test
   public void atomMembersAreConstructorFields_ManyConstructors() {
     var myTypeAtom =
@@ -110,6 +114,242 @@ public void atomMembersAreConstructorFields_ManyConstructors() {
         containsInAnyOrder("g1", "g2", "g3"));
   }
 
+  @Test
+  public void methodIsAtomMember() {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            Cons a b
+            method self = 42
+
+        main = My_Type.Cons "a" "b"
+        """);
+    assertThat("Method is a member of the atom", myTypeAtom.getMemberKeys(), hasItem("method"));
+    assertThat("method is an invokable member", myTypeAtom.canInvokeMember("method"), is(true));
+  }
+
+  @Test
+  public void methodIsAtomMember_InteropLibrary() {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            Cons a b
+            method self = 42
+
+        main = My_Type.Cons "a" "b"
+        """);
+    var atom = ContextUtils.unwrapValue(ctx, myTypeAtom);
+    var interop = InteropLibrary.getUncached();
+    assertThat("Atom has members", interop.hasMembers(atom), is(true));
+    assertThat("Method is readable", interop.isMemberReadable(atom, "method"), is(true));
+    assertThat("Method is invocable", interop.isMemberInvocable(atom, "method"), is(true));
+    assertThat("Field is readable", interop.isMemberReadable(atom, "a"), is(true));
+  }
+
+  @Test
+  public void fieldsFromPrivateConstructorAreInternalMembers() {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            private Cons a
+
+        main = My_Type.Cons "a"
+        """);
+    var atom = ContextUtils.unwrapValue(ctx, myTypeAtom);
+    var interop = InteropLibrary.getUncached();
+    assertThat("field a is internal", interop.isMemberInternal(atom, "a"), is(true));
+  }
+
+  @Test
+  public void fieldFromPrivateConstructorIsReadable() {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            private Cons a
+
+        main = My_Type.Cons "a"
+        """);
+    ContextUtils.executeInContext(
+        ctx,
+        () -> {
+          var atom = ContextUtils.unwrapValue(ctx, myTypeAtom);
+          var interop = InteropLibrary.getUncached();
+          assertThat(
+              "Field from private constructor is readable",
+              interop.isMemberReadable(atom, "a"),
+              is(true));
+          assertThat(
+              "Field from private constructor is invocable",
+              interop.isMemberInvocable(atom, "a"),
+              is(true));
+          assertThat(
+              "Field from private constructor can be read",
+              interop.asString(interop.readMember(atom, "a")),
+              is("a"));
+          assertThat(
+              "Field from private constructor can be invoked",
+              interop.asString(interop.invokeMember(atom, "a")),
+              is("a"));
+          return null;
+        });
+  }
+
+  @Test
+  public void allMethodsAreInternalMembers() {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            Cons a
+            pub_method self = 42
+            private priv_method self = 42
+
+        main = My_Type.Cons "a"
+        """);
+    var atom = ContextUtils.unwrapValue(ctx, myTypeAtom);
+    var interop = InteropLibrary.getUncached();
+    assertThat(
+        "public method is internal member", interop.isMemberInternal(atom, "pub_method"), is(true));
+    assertThat(
+        "private method is internal member",
+        interop.isMemberInternal(atom, "priv_method"),
+        is(true));
+  }
+
+  @Test
+  public void allMembersAreReadableAndInvocable()
+      throws UnsupportedMessageException, InvalidArrayIndexException {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            Cons a
+            pub_method self = 42
+            private priv_method self = 42
+
+        main = My_Type.Cons "a"
+        """);
+    var atom = ContextUtils.unwrapValue(ctx, myTypeAtom);
+    var interop = InteropLibrary.getUncached();
+    var members = interop.getMembers(atom, true);
+    for (long i = 0; i < interop.getArraySize(members); i++) {
+      var memberName = interop.asString(interop.readArrayElement(members, i));
+      assertThat(
+          "Member " + memberName + " should be readable",
+          interop.isMemberReadable(atom, memberName),
+          is(true));
+      assertThat(
+          "Member " + memberName + " should be invocable",
+          interop.isMemberInvocable(atom, memberName),
+          is(true));
+    }
+  }
+
+  @Test
+  public void constructorIsNotAtomMember() {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            Cons a b
+            method self = 42
+
+        main = My_Type.Cons "a" "b"
+        """);
+    assertThat("Cons is not atom member", myTypeAtom.getMemberKeys(), not(hasItem("Cons")));
+  }
+
+  @Test
+  public void fieldIsInvocable() {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            Cons a b
+
+        main = My_Type.Cons 1 2
+        """);
+    ContextUtils.executeInContext(
+        ctx,
+        () -> {
+          var atom = ContextUtils.unwrapValue(ctx, myTypeAtom);
+          var interop = InteropLibrary.getUncached();
+          assertThat("Field a is invocable", interop.isMemberInvocable(atom, "a"), is(true));
+          var aField = interop.invokeMember(atom, "a");
+          assertThat("Field is a number", interop.asInt(aField), is(1));
+          assertThat("Field b is invocable", interop.isMemberInvocable(atom, "b"), is(true));
+          return null;
+        });
+  }
+
+  @Test
+  public void fieldIsReadable() {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            Cons a
+
+        main = My_Type.Cons 1
+        """);
+    ContextUtils.executeInContext(
+        ctx,
+        () -> {
+          var atom = ContextUtils.unwrapValue(ctx, myTypeAtom);
+          var interop = InteropLibrary.getUncached();
+          assertThat("Field a is readable", interop.isMemberReadable(atom, "a"), is(true));
+          return null;
+        });
+  }
+
+  @Test
+  public void staticMethodIsNotAtomMember() {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            Cons
+            static_method = 42
+
+        main = My_Type.Cons
+        """);
+    assertThat(
+        "Static method is not atom member",
+        myTypeAtom.getMemberKeys(),
+        not(hasItem(containsString("static_method"))));
+  }
+
+  @Test
+  public void constructorIsNotAtomMember_InteropLibrary() {
+    var myTypeAtom =
+        ContextUtils.evalModule(
+            ctx,
+            """
+        type My_Type
+            Cons a b
+            method self = 42
+
+        main = My_Type.Cons "a" "b"
+        """);
+    var atom = ContextUtils.unwrapValue(ctx, myTypeAtom);
+    var interop = InteropLibrary.getUncached();
+    assertThat("Cons is not atom member", interop.isMemberExisting(atom, "Cons"), is(false));
+  }
+
   @Test
   public void typeMembersAreConstructors() {
     var myType =

engine/runtime-integration-tests/src/test/java/org/enso/interpreter/test/DebuggingEnsoTest.java

@@ -42,7 +42,6 @@
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 
 public class DebuggingEnsoTest {
@@ -483,7 +482,6 @@ public void testAtomFieldsAreReadable() {
     }
   }
 
-  @Ignore("https://github.com/enso-org/enso/issues/10675")
   @Test
   public void testAtomFieldAreReadable_MultipleConstructors() {
     var fooFunc =

engine/runtime-integration-tests/src/test/java/org/enso/interpreter/test/TypeMembersTest.java

@@ -4,13 +4,11 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
 
 import java.net.URI;
 import java.util.Set;
 import org.enso.test.utils.ContextUtils;
 import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.PolyglotException;
 import org.graalvm.polyglot.Source;
 import org.graalvm.polyglot.Value;
 import org.junit.After;
@@ -78,10 +76,9 @@ public void checkAtomMembers() throws Exception {
     assertEquals("seven check", 7, seven.asInt());
     assertEquals("three check", 3, three.asInt());
 
-    assertMembers("Keys in list1", false, headAtom, "head", "tail", "is_empty");
-    assertMembers("Keys in list2", false, endAtom, "head", "tail", "is_empty");
-    assertMembers("Keys in list1", false, headAtom, "h", "t");
-    assertMembers("Keys in list2", true, endAtom, "h", "t");
+    assertMembers("Keys in list1", headAtom, "head", "tail", "is_empty");
+    assertMembers("Keys in list2", endAtom, "head", "tail", "is_empty");
+    assertMembers("Keys in list1", headAtom, "h", "t");
   }
 
   @Test
@@ -105,24 +102,15 @@ public void ensureNonBuiltinMembersArePresent() throws Exception {
 
     var module = ctx.eval(src);
     var compileError = module.invokeMember("eval_expression", "v");
-    assertEquals("all members", compileError.getMemberKeys(), Set.of("to_display_text", "message"));
+    assertEquals("all members", Set.of("to_display_text", "message"), compileError.getMemberKeys());
   }
 
-  private static void assertMembers(String msg, boolean invokeFails, Value v, String... keys) {
+  private static void assertMembers(String msg, Value v, String... keys) {
     var realKeys = v.getMemberKeys();
     for (var k : keys) {
       assertTrue(msg + " - found " + k + " in " + realKeys, realKeys.contains(k));
       assertTrue(msg + " - has member " + k, v.hasMember(k));
-      if (invokeFails) {
-        try {
-          v.invokeMember(k);
-          fail("Invoking " + k + " on " + v + " shall fail");
-        } catch (PolyglotException ex) {
-          assertEquals("Field `" + k + "` of IntList could not be found.", ex.getMessage());
-        }
-      } else {
-        assertNotNull(msg + " - can be invoked", v.invokeMember(k));
-      }
+      assertNotNull(msg + " - can be invoked", v.invokeMember(k));
     }
   }
 }