Rename render to renderValue (#1964)

Motivation: preserve a possible API change to have `FormattingRenderer`
extend `ValueRenderer`.

pkl-core/src/main/java/org/pkl/core/stdlib/syntax/FormattingRendererNodes.java

@@ -31,7 +31,7 @@ import org.pkl.parser.syntax.generic.Node;
 public final class FormattingRendererNodes {
   private FormattingRendererNodes() {}
 
-  public abstract static class render extends ExternalMethod1Node {
+  public abstract static class renderValue extends ExternalMethod1Node {
     @Specialization
     protected String eval(
         VmTyped self, VmTyped nodeVm, @Cached("create()") IndirectCallNode callNode) {

pkl-core/src/test/files/LanguageSnippetTests/input/syntax/query.pkl

@@ -135,25 +135,25 @@ facts {
   }
 
   ["replaceChild replaces only the first match"] {
-    renderer.render(
+    renderer.renderValue(
       mod("x = 1 + 1").replaceChild((n) -> n.type == "int_literal_expr", (_n) -> intLiteral(9)),
     ) == "x = 9 + 1\n"
   }
 
   ["replaceChild leaves the tree unchanged when nothing matches"] {
-    renderer.render(
+    renderer.renderValue(
       mod("x = 1").replaceChild((n) -> n.type == "when_generator", (_n) -> intLiteral(9)),
     ) == "x = 1\n"
   }
 
   ["replaceChildren replaces every match"] {
-    renderer.render(
+    renderer.renderValue(
       mod("x = 1 + 1").replaceChildren((n) -> n.type == "int_literal_expr", (_n) -> intLiteral(9)),
     ) == "x = 9 + 9\n"
   }
 
   ["a replacer sees the node it replaces"] {
-    renderer.render(
+    renderer.renderValue(
       mod("x = 1 + 2")
         .replaceChildren(
           (n) -> n.type == "int_literal_expr",
@@ -164,14 +164,14 @@ facts {
 
   ["a replacement is not searched for further matches"] {
     // replacing an identifier with an identifier terminates instead of looping
-    renderer.render(
+    renderer.renderValue(
       mod("foo = 1").replaceChildrenOfType("identifier", (n) -> (n) { text = "\(n.text!!)Bar" }),
     ) == "fooBar = 1\n"
   }
 
   ["replaceChildOfType agrees with replaceChild"] {
-    renderer.render(mod("x = 1 + 1").replaceChildOfType("int_literal_expr", (_n) -> intLiteral(9)))
-      == renderer.render(
+    renderer.renderValue(mod("x = 1 + 1").replaceChildOfType("int_literal_expr", (_n) -> intLiteral(9)))
+      == renderer.renderValue(
         mod("x = 1 + 1").replaceChild((n) -> n.type == "int_literal_expr", (_n) -> intLiteral(9)),
       )
   }
@@ -182,14 +182,14 @@ facts {
         .replaceChildOfType("int_literal_expr", (n) ->
           if (n.hasParentOfType("class_property")) intLiteral(9) else intLiteral(0)
         )
-    renderer.render(result) == "x = 9\n"
+    renderer.renderValue(result) == "x = 9\n"
   }
 
   ["a replace does not change the tree it walks"] {
     local original = mod("x = 1")
     local rewritten = original.replaceChildrenOfType("int_literal_expr", (_n) -> intLiteral(9))
-    let (rendered = renderer.render(rewritten))
-      rendered == "x = 9\n" && renderer.render(original) == "x = 1\n"
+    let (rendered = renderer.renderValue(rewritten))
+      rendered == "x = 9\n" && renderer.renderValue(original) == "x = 1\n"
   }
 
   ["the root of a replaced tree has no parent"] {
@@ -221,7 +221,7 @@ facts {
           .findChildrenOfType("int_literal_expr")
           .fold(0, (acc, c) -> acc + c.text!!.toInt()),
       )
-    renderer.render(mod("x = 1 + 2").replaceChildrenOfType("int_literal_expr", sumOfSiblings))
+    renderer.renderValue(mod("x = 1 + 2").replaceChildrenOfType("int_literal_expr", sumOfSiblings))
       == "x = 3 + 3\n"
   }
 
@@ -234,7 +234,7 @@ facts {
   }
 
   ["rebuilds ancestors of a replacement"] {
-    renderer.render(
+    renderer.renderValue(
       mod("x = if (cond) 41 else 0")
         .replaceChildrenOfType("int_literal_expr", (n) -> intLiteral(n.text!!.toInt() + 1)),
     ) == "x = if (cond) 42 else 1\n"
@@ -246,7 +246,7 @@ facts {
         throw("searched inside a match")
       else
         n.type == "parenthesized_expr"
-    renderer.render(mod("x = (1)").replaceChildren(predicate, (_) -> intLiteral(9))) == "x = 9\n"
+    renderer.renderValue(mod("x = (1)").replaceChildren(predicate, (_) -> intLiteral(9))) == "x = 9\n"
   }
 
   ["replacement is eager"] {

pkl-core/src/test/files/LanguageSnippetTests/input/syntax/render.pkl

@@ -5,10 +5,9 @@ import "pkl:test"
 
 local renderer = new syntax.FormattingRenderer {}
 
-local function roundTrip(source: String) = renderer.render(parseNode(source))
+local function roundTrip(source: String) = renderer.renderValue(parseNode(source))
 
-local function parseNode(source: String): syntax.Node =
-  new syntax.Parser {}.parseModule(source)
+local function parseNode(source: String): syntax.Node = new syntax.Parser {}.parseModule(source)
 
 local function replaceLeaf(
   node: syntax.Node,
@@ -340,37 +339,37 @@ facts {
   ["modify identifier"] {
     local root = parseNode("x = 1")
     local modified = replaceLeaf(root, "identifier", "x", "y")
-    renderer.render(modified) == "y = 1\n"
+    renderer.renderValue(modified) == "y = 1\n"
   }
 
   ["modify modifier"] {
     local root = parseNode("hidden x = 1")
     local modified = replaceLeaf(root, "modifier", "hidden", "local")
-    renderer.render(modified) == "local x = 1\n"
+    renderer.renderValue(modified) == "local x = 1\n"
   }
 
   ["modify string content"] {
     local root = parseNode(#"x = "hello""#)
     local modified = replaceLeaf(root, "string_chars", "hello", "world")
-    renderer.render(modified) == #"x = "world"\#n"#
+    renderer.renderValue(modified) == #"x = "world"\#n"#
   }
 
   ["modify int literal"] {
     local root = parseNode("x = 42")
     local modified = replaceLeaf(root, "int_literal_expr", "42", "99")
-    renderer.render(modified) == "x = 99\n"
+    renderer.renderValue(modified) == "x = 99\n"
   }
 
   ["modify boolean literal"] {
     local root = parseNode("x = true")
     local modified = replaceLeaf(root, "bool_literal_expr", "true", "false")
-    renderer.render(modified) == "x = false\n"
+    renderer.renderValue(modified) == "x = false\n"
   }
 
   ["modify float literal"] {
     local root = parseNode("x = 3.14")
     local modified = replaceLeaf(root, "float_literal_expr", "3.14", "2.72")
-    renderer.render(modified) == "x = 2.72\n"
+    renderer.renderValue(modified) == "x = 2.72\n"
   }
 
   ["add new modifier"] {
@@ -384,7 +383,8 @@ facts {
         children = List(constModifier) + n.children
       })
     // modifier order is switched by the formatter
-    renderer.render(modified) == """
+    renderer.renderValue(modified)
+      == """
       local const x = 1
 
       """
@@ -392,14 +392,17 @@ facts {
 
   ["a default renderer targets the V2 grammar"] {
     local node = parseNode("x = 1")
-    renderer.render(node) == new syntax.FormattingRenderer { grammarVersion = "V2" }.render(node)
+    renderer.renderValue(node)
+      == new syntax.FormattingRenderer { grammarVersion = "V2" }.renderValue(node)
   }
 
   ["renderer honors the grammar version"] {
     local node =
-      parseNode("x = fn(argument1, argument2, argument3, argument4, argument5, argument6, argument7, argument8, argument9)")
-    new syntax.FormattingRenderer { grammarVersion = "V1" }.render(node)
-      != new syntax.FormattingRenderer { grammarVersion = "V2" }.render(node)
+      parseNode(
+        "x = fn(argument1, argument2, argument3, argument4, argument5, argument6, argument7, argument8, argument9)",
+      )
+    new syntax.FormattingRenderer { grammarVersion = "V1" }.renderValue(node)
+      != new syntax.FormattingRenderer { grammarVersion = "V2" }.renderValue(node)
   }
 
   ["a malformed tree is reported as such"] {
@@ -407,7 +410,8 @@ facts {
       type = "object_element"
       children = List()
     }
-    test.catch(() -> renderer.render(malformed))
+    test
+      .catch(() -> renderer.renderValue(malformed))
       .contains("Could not render node of type `object_element` as Pkl source")
   }
 }

pkl-core/src/test/files/LanguageSnippetTests/input/syntax/spans.pkl

@@ -64,7 +64,7 @@ facts {
 
   ["a spanless constructed node still renders"] {
     new syntax.FormattingRenderer {}
-      .render(new syntax.Node { type = "int_literal_expr"; text = "42" })
+      .renderValue(new syntax.Node { type = "int_literal_expr"; text = "42" })
       .trim() == "42"
   }
 

stdlib/syntax.pkl

@@ -46,7 +46,7 @@ class FormattingRenderer {
   grammarVersion: "V1" | "V2" = "V2"
 
   /// Render [node] as Pkl source code.
-  external function render(node: Node): String
+  external function renderValue(node: Node): String
 }
 
 /// A generic, untyped node in the Pkl syntax tree.