refine domain rendering to string, remove default rendering behaviors

Author: HT154

pkl-core/src/main/java/org/pkl/core/PClass.java

@@ -60,7 +60,7 @@ public void initSupertype(PType supertype, PClass superclass) {
 
   /**
    * Returns the name of the module that this class is declared in. Note that a module name is not
-   * guaranteed to be unique, especially if it not declared but inferred from the module URI.
+   * guaranteed to be unique, especially if it is not declared but inferred from the module URI.
    */
   public String getModuleName() {
     return classInfo.getModuleName();

pkl-core/src/main/java/org/pkl/core/PType.java

@@ -125,6 +125,13 @@ public String toString() {
       }
       return result;
     }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) return true;
+      if (!(obj instanceof Class clazz)) return false;
+      return pClass == clazz.getPClass() && typeArguments.equals(clazz.getTypeArguments());
+    }
   }
 
   public static final class Nullable extends PType {

pkl-core/src/main/java/org/pkl/core/runtime/VmReference.java

@@ -15,7 +15,6 @@
  */
 package org.pkl.core.runtime;
 
-import com.oracle.truffle.api.nodes.DirectCallNode;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -43,7 +42,8 @@ public final class VmReference extends VmValue {
 
   private boolean forced = false;
 
-  private static final PType nullType = new PType.Class(BaseModule.getNullClass().export());
+  private static final PType.Class nullType = new PType.Class(BaseModule.getNullClass().export());
+  private static final PType.Class anyType = new PType.Class(BaseModule.getAnyClass().export());
   private static final Set<TypeAlias> intAliasTypes = new HashSet<>();
   private static final Set<TypeAlias> preservedAliasTypes = new HashSet<>();
 
@@ -54,14 +54,6 @@ public final class VmReference extends VmValue {
     }
   }
 
-  private static final DirectCallNode toStringCallNode;
-
-  static {
-    var toStringMethod = RefModule.getReferenceClass().getMethod(Identifier.TO_STRING);
-    assert toStringMethod != null;
-    toStringCallNode = DirectCallNode.create(toStringMethod.getCallTarget());
-  }
-
   private static VmTyped newAccess(@Nullable String property, @Nullable Object key) {
     return new VmObjectBuilder()
         .addProperty(Identifier.PROPERTY, property == null ? VmNull.withoutDefault() : property)
@@ -106,11 +98,13 @@ public List<VmTyped> getPath() {
   private static Set<PType> normalizeTypes(PType type, PClass moduleClass) {
     var types = new HashSet<PType>();
     normalizeTypes(type, moduleClass, types);
+    if (types.contains(PType.UNKNOWN)) return Set.of(PType.UNKNOWN);
+    if (containsClass(types, anyType.getPClass())) return Set.of(anyType);
     return types;
   }
 
   private static void normalizeTypes(PType type, PClass moduleClass, Set<PType> result) {
-    if (type == PType.UNKNOWN || type instanceof PType.StringLiteral) {
+    if (type == PType.UNKNOWN || type == PType.NOTHING || type instanceof PType.StringLiteral) {
       result.add(type);
     } else if (type instanceof PType.Class clazz) {
       if (clazz.getTypeArguments().isEmpty()) {
@@ -257,12 +251,20 @@ private static void getCandidateSubscriptType(PType type, Object key, Set<PType>
    * Tells if this reference's referent type is a subtype of {@code type}. Does not check domain.
    */
   public boolean referentTypeIsSubtypeOf(PType type, PClass moduleClass) {
-    // fast path: if this could be unknown, any type is accepted
+    // fast path: if referent is unknown it can match any type check
     if (candidateTypes.contains(PType.UNKNOWN)) {
       return true;
     }
 
     var checkTypes = normalizeTypes(type, moduleClass);
+    // fast path: short circuit if any referent is accepted
+    if (checkTypes.contains(PType.UNKNOWN) || containsClass(checkTypes, anyType.getPClass())) {
+      return true;
+    }
+    // fast path: short circuit if nothing is accepted
+    if (checkTypes.size() == 1 && checkTypes.contains(PType.NOTHING)) {
+      return false;
+    }
 
     // all candidate types must be subtypes of at least one target type
     candidate:
@@ -275,6 +277,13 @@ public boolean referentTypeIsSubtypeOf(PType type, PClass moduleClass) {
     return true;
   }
 
+  private static boolean containsClass(Set<PType> types, PClass pClass) {
+    for (var t : types) {
+      if (t instanceof PType.Class clazz && clazz.getPClass() == pClass) return true;
+    }
+    return false;
+  }
+
   private static boolean isSubtype(PType a, PType b) {
     // checks if A is a subtype of B
     // cases (A -> B)
@@ -435,8 +444,4 @@ public int hashCode() {
     result = 31 * result + candidateTypes.hashCode();
     return result;
   }
-
-  public String toPklString() {
-    return (String) toStringCallNode.call(this, getVmClass().getPrototype());
-  }
 }

pkl-core/src/main/java/org/pkl/core/stdlib/AbstractStringRenderer.java

@@ -17,7 +17,6 @@
 
 import org.pkl.core.runtime.VmClass;
 import org.pkl.core.runtime.VmFunction;
-import org.pkl.core.runtime.VmReference;
 import org.pkl.core.runtime.VmTypeAlias;
 
 /** Base class for renderers that are part of the standard library. */
@@ -52,11 +51,6 @@ protected void decreaseIndent() {
     currIndent.setLength(currIndent.length() - indent.length());
   }
 
-  @Override
-  public void visitReference(VmReference value) {
-    visitString(value.toPklString());
-  }
-
   // override these to mark them final
 
   @Override

pkl-core/src/test/files/LanguageSnippetTests/input/api/reference.pkl

@@ -2,15 +2,21 @@ import "pkl:math"
 import "pkl:ref"
 
 class D extends ref.Domain {
-  function referenceToString(data: Any, path: List<ref.Access>): String =
-    if (data is Resource)
-      let (path = path.map((elem) -> if (elem.isProperty) ".\(elem.property)" else "[\(elem.key)]"))
-        "${\(data.name)\(path.join(""))}"
-    else
-      throw("can only render references rooted to Resource instances")
+  function renderReference(reference: ref.Reference<D, Any>): String =
+    let (data = reference.getData())
+      if (data is Resource)
+        let (
+          path =
+            reference
+              .getPath()
+              .map((elem) -> if (elem.isProperty) ".\(elem.property)" else "[\(elem.key)]")
+        )
+          "${\(data.name)\(path.join(""))}"
+      else
+        throw("can only render references rooted to Resource instances")
 }
 
-const local d: D = new {}
+local const d: D = new {}
 typealias Ref<T> = ref.Reference<D, T>
 
 abstract class Resource {
@@ -51,7 +57,7 @@ class BProperties {
 
 class MapKey {
   k: Int
-  
+
   function toString(): String = "key:\(k)"
 }
 
@@ -114,3 +120,11 @@ j: K = new {
 refInterpolation = "\(aRef.outputs.someListing[1])"
 kInterpolation = "\(k)"
 aValuesJoined = k.aValues.join("\n").replaceAll(Regex("@[a-z0-9]+"), "@<addr>")
+
+output {
+  renderer {
+    converters {
+      [ref.Reference] = (it) -> it.toString()
+    }
+  }
+}

pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference1.pkl

@@ -1,7 +1,7 @@
 import "pkl:ref"
 
 class D extends ref.Domain {
-  function referenceToString(data: Any, path: List<ref.Access>): String = throw("not supported")
+  function renderReference(reference: ref.Reference<D, Any>): String = throw("not supported")
 }
 local d: D = new {}
 typealias Ref<T> = ref.Reference<D, T>

pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference10.pkl

@@ -1,7 +1,7 @@
 import "pkl:ref"
 
 class D extends ref.Domain {
-  function referenceToString(data: Any, path: List<ref.Access>): String = throw("not supported")
+  function renderReference(reference: ref.Reference<D, Any>): String = throw("not supported")
 }
 typealias Ref<T> = ref.Reference<D, T>
 local d: D = new {}

pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference11.pkl

@@ -1,7 +1,7 @@
 import "pkl:ref"
 
 class D extends ref.Domain {
-  function referenceToString(data: Any, path: List<ref.Access>): String = throw("not supported")
+  function renderReference(reference: ref.Reference<D, Any>): String = throw("not supported")
 }
 typealias Ref<T> = ref.Reference<D, T>
 local d: D = new {}

pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference12.pkl

@@ -1,7 +1,7 @@
 import "pkl:ref"
 
 class D extends ref.Domain {
-  function referenceToString(data: Any, path: List<ref.Access>): String = throw("not supported")
+  function renderReference(reference: ref.Reference<D, Any>): String = throw("not supported")
 }
 typealias RefAlias1 = ref.Reference<D, Alias1?>
 local d: D = new {}

pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference13.pkl

@@ -1,7 +1,7 @@
 import "pkl:ref"
 
 class D extends ref.Domain {
-  function referenceToString(data: Any, path: List<ref.Access>): String = throw("not supported")
+  function renderReference(reference: ref.Reference<D, Any>): String = throw("not supported")
 }
 local d: D = new {}