From 85b4a4669a9fb75e08cb5d264e8ab9718efd982a Mon Sep 17 00:00:00 2001 From: Daniel Chao Date: Thu, 5 Nov 2026 08:39:33 -0800 Subject: [PATCH] Rename render to renderValue (#1964) Motivation: preserve a possible API change to have `FormattingRenderer` extend `ValueRenderer`. --- .../syntax/FormattingRendererNodes.java | 2 +- .../input/syntax/query.pkl | 26 +++++++------- .../input/syntax/render.pkl | 34 +++++++++++-------- .../input/syntax/spans.pkl | 2 +- stdlib/syntax.pkl | 2 +- 5 files changed, 35 insertions(+), 31 deletions(-) diff --git a/pkl-core/src/main/java/org/pkl/core/stdlib/syntax/FormattingRendererNodes.java b/pkl-core/src/main/java/org/pkl/core/stdlib/syntax/FormattingRendererNodes.java index 7b36edae0..9f7d4b562 100644 --- a/pkl-core/src/main/java/org/pkl/core/stdlib/syntax/FormattingRendererNodes.java +++ b/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) { diff --git a/pkl-core/src/test/files/LanguageSnippetTests/input/syntax/query.pkl b/pkl-core/src/test/files/LanguageSnippetTests/input/syntax/query.pkl index 168657313..ccbc380ae 100644 --- a/pkl-core/src/test/files/LanguageSnippetTests/input/syntax/query.pkl +++ b/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"] { diff --git a/pkl-core/src/test/files/LanguageSnippetTests/input/syntax/render.pkl b/pkl-core/src/test/files/LanguageSnippetTests/input/syntax/render.pkl index b11f7101f..39fcffb89 100644 --- a/pkl-core/src/test/files/LanguageSnippetTests/input/syntax/render.pkl +++ b/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") } } diff --git a/pkl-core/src/test/files/LanguageSnippetTests/input/syntax/spans.pkl b/pkl-core/src/test/files/LanguageSnippetTests/input/syntax/spans.pkl index b81e6a0d9..b534ee640 100644 --- a/pkl-core/src/test/files/LanguageSnippetTests/input/syntax/spans.pkl +++ b/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" } diff --git a/stdlib/syntax.pkl b/stdlib/syntax.pkl index 5466a4afc..d861386bb 100644 --- a/stdlib/syntax.pkl +++ b/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.