Add pkl:syntax stdlib module (#1821)

This commit is contained in:
Islon Scherer authored and GitHub committed 2026-10-23 15:51:22 +02:00
1 parent 0cb9843af7
commit 939e844c03
48 files changed
+3149 -214

No files matched your search

@@ -81,7 +81,7 @@ import org.pkl.parser.syntax.Type.ModuleType;
import org.pkl.parser.syntax.Type.NothingType;
import org.pkl.parser.syntax.Type.NullableType;
import org.pkl.parser.syntax.Type.ParenthesizedType;
import org.pkl.parser.syntax.Type.StringConstantType;
import org.pkl.parser.syntax.Type.StringLiteralType;
import org.pkl.parser.syntax.Type.ThisType;
import org.pkl.parser.syntax.Type.UnionType;
import org.pkl.parser.syntax.Type.UnknownType;
@@ -114,7 +114,7 @@ public abstract class BaseParserVisitor<T> implements ParserVisitor<T> {
}
@Override
public T visitStringConstantType(StringConstantType type) {
public T visitStringLiteralType(StringLiteralType type) {
return visitChildren(type);
}
@@ -21,4 +21,8 @@ public final class GenericParser {
public Node parseModule(String source) {
return new GenericParserImpl(source).parseModule();
}
public Node parseExpressionInput(String source) {
return new GenericParserImpl(source).parseExpressionInput();
}
}
@@ -17,6 +17,7 @@ package org.pkl.parser;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Supplier;
import org.jspecify.annotations.Nullable;
import org.pkl.parser.syntax.Operator;
@@ -37,10 +38,14 @@ class GenericParserImpl {
GenericParserImpl(String source) {
this.lexer = new Lexer(source);
while (true) {
var ft = new FullToken(lexer.next(), lexer.fullSpan(), lexer.getNewLinesBetween());
tokens.add(ft);
if (ft.token == Token.EOF) break;
try {
while (true) {
var ft = new FullToken(lexer.next(), lexer.fullSpan(), lexer.getNewLinesBetween());
tokens.add(ft);
if (ft.token == Token.EOF) break;
}
} catch (ParserError e) {
throw parserError(Objects.requireNonNull(e.getMessage()), lexer.fullSpan());
}
_lookahead = tokens.get(cursor);
lookahead = _lookahead.token;
@@ -102,6 +107,16 @@ class GenericParserImpl {
return new Node(NodeType.MODULE, nodes);
}
Node parseExpressionInput() {
ff();
var expr = parseExpr();
ff();
if (lookahead != Token.EOF) {
throw parserError("unexpectedToken", _lookahead.text(lexer), "end of file");
}
return expr;
}
private Node parseModuleDecl(List<Node> preChildren) {
var headerParts = getHeaderParts(preChildren);
var children = new ArrayList<>(headerParts.preffixes);
@@ -139,7 +154,7 @@ class GenericParserImpl {
children.add(parseIdentifier());
while (lookahead() == Token.DOT) {
ff(children);
children.add(new Node(NodeType.TERMINAL, next().span));
children.add(makeTerminal(next()));
ff(children);
children.add(parseIdentifier());
}
@@ -222,13 +237,13 @@ class GenericParserImpl {
headers.add(makeTerminal(next()));
ff(headers);
headers.add(parseIdentifier());
ff(headers);
if (lookahead == Token.LT) {
headers.add(parseTypeParameterList());
if (lookahead() == Token.LT) {
ff(headers);
headers.add(parseTypeParameterList());
}
expect(Token.ASSIGN, headers, "unexpectedToken", "=");
children.add(new Node(NodeType.TYPEALIAS_HEADER, headers));
ff(children);
expect(Token.ASSIGN, children, "unexpectedToken", "=");
var body = new ArrayList<Node>();
ff(body);
body.add(parseType());
@@ -307,13 +322,13 @@ class GenericParserImpl {
}
headerBegin.add(parseIdentifier());
header.add(new Node(NodeType.CLASS_PROPERTY_HEADER_BEGIN, headerBegin));
children.add(new Node(NodeType.CLASS_PROPERTY_HEADER, header));
var hasTypeAnnotation = false;
if (lookahead() == Token.COLON) {
ff(header);
header.add(parseTypeAnnotation());
ff(children);
children.add(parseTypeAnnotation());
hasTypeAnnotation = true;
}
children.add(new Node(NodeType.CLASS_PROPERTY_HEADER, header));
if (lookahead() == Token.ASSIGN) {
ff(children);
children.add(makeTerminal(next()));
@@ -343,7 +358,7 @@ class GenericParserImpl {
expect(Token.FUNCTION, headers, "unexpectedToken", "function");
ff(headers);
headers.add(parseIdentifier());
children.add(new Node(NodeType.CLASS_METHOD_HEADER, headers));
children.add(new Node(NodeType.METHOD_HEADER, headers));
ff(children);
if (lookahead == Token.LT) {
children.add(parseTypeParameterList());
@@ -360,7 +375,7 @@ class GenericParserImpl {
var body = new ArrayList<Node>();
ff(body);
body.add(parseExpr());
children.add(new Node(NodeType.CLASS_METHOD_BODY, body));
children.add(new Node(NodeType.METHOD_BODY, body));
}
return new Node(NodeType.CLASS_METHOD, children);
}
@@ -391,7 +406,7 @@ class GenericParserImpl {
ff(members);
}
if (!members.isEmpty()) {
children.add(new Node(NodeType.OBJECT_MEMBER_LIST, members));
children.add(new Node(NodeType.OBJECT_MEMBER_ELEMENTS, members));
}
children.add(makeTerminal(next())); // RBRACE
return new Node(NodeType.OBJECT_BODY, children);
@@ -484,13 +499,13 @@ class GenericParserImpl {
}
headerBegin.add(parseIdentifier());
header.add(new Node(NodeType.OBJECT_PROPERTY_HEADER_BEGIN, headerBegin));
children.add(new Node(NodeType.OBJECT_PROPERTY_HEADER, header));
var hasTypeAnnotation = false;
if (lookahead() == Token.COLON) {
ff(header);
header.add(parseTypeAnnotation());
ff(children);
children.add(parseTypeAnnotation());
hasTypeAnnotation = true;
}
children.add(new Node(NodeType.OBJECT_PROPERTY_HEADER, header));
if (hasTypeAnnotation || lookahead() == Token.ASSIGN) {
ff(children);
expect(Token.ASSIGN, children, "unexpectedToken", "=");
@@ -515,7 +530,7 @@ class GenericParserImpl {
expect(Token.FUNCTION, headers, "unexpectedToken", "function");
ff(headers);
headers.add(parseIdentifier());
children.add(new Node(NodeType.CLASS_METHOD_HEADER, headers));
children.add(new Node(NodeType.METHOD_HEADER, headers));
ff(children);
if (lookahead == Token.LT) {
children.add(parseTypeParameterList());
@@ -531,20 +546,22 @@ class GenericParserImpl {
var body = new ArrayList<Node>();
ff(body);
body.add(parseExpr());
children.add(new Node(NodeType.CLASS_METHOD_BODY, body));
children.add(new Node(NodeType.METHOD_BODY, body));
return new Node(NodeType.OBJECT_METHOD, children);
}
private Node parseMemberPredicate() {
var children = new ArrayList<Node>();
children.add(makeTerminal(next()));
ff(children);
children.add(parseExpr());
ff(children);
var header = new ArrayList<Node>();
header.add(makeTerminal(next()));
ff(header);
header.add(parseExpr());
ff(header);
var firstBrack = expect(Token.RBRACK, "unexpectedToken", "]]");
children.add(makeTerminal(firstBrack));
header.add(makeTerminal(firstBrack));
var secondbrack = expect(Token.RBRACK, "unexpectedToken", "]]");
children.add(makeTerminal(secondbrack));
header.add(makeTerminal(secondbrack));
children.add(new Node(NodeType.MEMBER_PREDICATE_HEADER, header));
if (firstBrack.span.charIndex() != secondbrack.span.charIndex() - 1) {
// There shouldn't be any whitespace between the first and second ']'.
var span = firstBrack.span.endWith(secondbrack.span);
@@ -569,16 +586,14 @@ class GenericParserImpl {
ff(header);
header.add(parseExpr());
expect(Token.RBRACK, header, "unexpectedToken", "]");
if (lookahead() == Token.ASSIGN) {
ff(header);
header.add(makeTerminal(next()));
children.add(new Node(NodeType.OBJECT_ENTRY_HEADER, header));
children.add(new Node(NodeType.OBJECT_ENTRY_HEADER, header));
ff(children);
if (lookahead == Token.ASSIGN) {
children.add(makeTerminal(next()));
ff(children);
children.add(parseExpr());
return new Node(NodeType.OBJECT_ENTRY, children);
}
children.add(new Node(NodeType.OBJECT_ENTRY_HEADER, header));
ff(children);
children.addAll(parseBodyList());
return new Node(NodeType.OBJECT_ENTRY, children);
}
@@ -937,7 +952,9 @@ class GenericParserImpl {
var token = next().token;
ff();
if (token == Token.RPAREN) {
return lookahead == Token.ARROW;
// `()` is only valid as an empty parameter list
// let `parseFunctionLiteral` report the missing `->`
return true;
}
if (token == Token.UNDERSCORE) {
return true;
@@ -1072,16 +1089,9 @@ class GenericParserImpl {
private Node parseParenthesizedExpr() {
var children = new ArrayList<Node>();
expect(Token.LPAREN, children, "unexpectedToken", "(");
if (lookahead() == Token.RPAREN) {
ff(children);
children.add(makeTerminal(next()));
return new Node(NodeType.PARENTHESIZED_EXPR, children);
}
var elements = new ArrayList<Node>();
ff(elements);
elements.add(parseExpr(")"));
ff(elements);
children.add(new Node(NodeType.PARENTHESIZED_EXPR_ELEMENTS, elements));
ff(children);
children.add(parseExpr(")"));
ff(children);
expect(Token.RPAREN, children, "unexpectedToken", ")");
return new Node(NodeType.PARENTHESIZED_EXPR, children);
}
@@ -1211,7 +1221,7 @@ class GenericParserImpl {
yield new Node(NodeType.DECLARED_TYPE, children);
}
case STRING_START ->
new Node(NodeType.STRING_CONSTANT_TYPE, List.of(parseStringConstant()));
new Node(NodeType.STRING_LITERAL_TYPE, List.of(parseStringConstant()));
default -> {
var text = _lookahead.text(lexer);
if (expectation != null) {
@@ -1381,14 +1391,14 @@ class GenericParserImpl {
children.add(makeTerminal(startTk));
while (lookahead != Token.STRING_END) {
switch (lookahead) {
case STRING_PART,
STRING_ESCAPE_NEWLINE,
case STRING_PART -> children.add(make(NodeType.STRING_CHARS, next().span));
case STRING_ESCAPE_NEWLINE,
STRING_ESCAPE_TAB,
STRING_ESCAPE_QUOTE,
STRING_ESCAPE_BACKSLASH,
STRING_ESCAPE_RETURN,
STRING_ESCAPE_UNICODE ->
children.add(makeTerminal(next()));
children.add(make(NodeType.STRING_ESCAPE, next().span));
case EOF -> {
var delimiter = new StringBuilder(startTk.text(lexer)).reverse().toString();
throw parserError("missingDelimiter", delimiter);
@@ -1399,7 +1409,7 @@ class GenericParserImpl {
}
}
children.add(makeTerminal(next())); // string end
return new Node(NodeType.STRING_CHARS, children);
return new Node(NodeType.STRING_CONSTANT, children);
}
private FullToken expect(Token type, String errorKey, Object... messageArgs) {
@@ -1542,7 +1552,64 @@ class GenericParserImpl {
}
private Node makeTerminal(FullToken tk) {
return new Node(NodeType.TERMINAL, tk.span);
var nodeType =
switch (tk.token) {
// keywords
case AMENDS -> NodeType.AMENDS_KEYWORD;
case AS -> NodeType.AS_KEYWORD;
case CLASS -> NodeType.CLASS_KEYWORD;
case ELSE -> NodeType.ELSE_KEYWORD;
case EXTENDS -> NodeType.EXTENDS_KEYWORD;
case FOR -> NodeType.FOR_KEYWORD;
case FUNCTION -> NodeType.FUNCTION_KEYWORD;
case IF -> NodeType.IF_KEYWORD;
case IMPORT -> NodeType.IMPORT_KEYWORD;
case IMPORT_STAR -> NodeType.IMPORT_STAR_KEYWORD;
case IN -> NodeType.IN_KEYWORD;
case LET -> NodeType.LET_KEYWORD;
case MODULE -> NodeType.MODULE_KEYWORD;
case NEW -> NodeType.NEW_KEYWORD;
case OUT -> NodeType.OUT_KEYWORD;
case READ -> NodeType.READ_KEYWORD;
case READ_QUESTION -> NodeType.READ_QUESTION_KEYWORD;
case READ_STAR -> NodeType.READ_STAR_KEYWORD;
case SUPER -> NodeType.SUPER_KEYWORD;
case THROW -> NodeType.THROW_KEYWORD;
case TRACE -> NodeType.TRACE_KEYWORD;
case TYPE_ALIAS -> NodeType.TYPEALIAS_KEYWORD;
case WHEN -> NodeType.WHEN_KEYWORD;
// punctuation
case ARROW -> NodeType.ARROW;
case ASSIGN -> NodeType.ASSIGN;
case AT -> NodeType.AT;
case COLON -> NodeType.COLON;
case COMMA -> NodeType.COMMA;
case DOT -> NodeType.DOT;
case GT -> NodeType.GT;
case LBRACE -> NodeType.LBRACE;
case LBRACK -> NodeType.LBRACK;
case LPAREN -> NodeType.LPAREN;
case LPRED -> NodeType.LPRED;
case LT -> NodeType.LT;
case MINUS -> NodeType.MINUS;
case NOT -> NodeType.NOT;
case QSPREAD -> NodeType.QSPREAD;
case QUESTION -> NodeType.QUESTION;
case RBRACE -> NodeType.RBRACE;
case RBRACK -> NodeType.RBRACK;
case RPAREN -> NodeType.RPAREN;
case SPREAD -> NodeType.SPREAD;
case STAR -> NodeType.STAR;
case UNDERSCORE -> NodeType.UNDERSCORE;
case UNION -> NodeType.UNION;
// string delimiters
case INTERPOLATION_START -> NodeType.INTERPOLATION_START;
case STRING_START -> NodeType.STRING_START;
case STRING_MULTI_START -> NodeType.STRING_MULTI_START;
case STRING_END -> NodeType.STRING_END;
default -> throw new RuntimeException("Unreacheable code");
};
return new Node(nodeType, tk.span);
}
// fast-forward over affix tokens
@@ -79,7 +79,7 @@ import org.pkl.parser.syntax.StringPart.StringChars;
import org.pkl.parser.syntax.Type;
import org.pkl.parser.syntax.Type.DeclaredType;
import org.pkl.parser.syntax.Type.ParenthesizedType;
import org.pkl.parser.syntax.Type.StringConstantType;
import org.pkl.parser.syntax.Type.StringLiteralType;
import org.pkl.parser.syntax.TypeAlias;
import org.pkl.parser.syntax.TypeAnnotation;
import org.pkl.parser.syntax.TypeArgumentList;
@@ -1427,7 +1427,7 @@ final class ParserImpl {
}
case STRING_START -> {
var str = parseStringConstant();
typ = new StringConstantType(str, str.span());
typ = new StringLiteralType(str, str.span());
}
default -> {
var text = _lookahead.text(lexer);
@@ -84,7 +84,7 @@ public interface ParserVisitor<Result> {
Result visitThisType(Type.ThisType type);
Result visitStringConstantType(Type.StringConstantType type);
Result visitStringLiteralType(Type.StringLiteralType type);
Result visitDeclaredType(Type.DeclaredType type);
@@ -72,14 +72,14 @@ public abstract sealed class Type extends AbstractNode {
}
}
public static final class StringConstantType extends Type {
public StringConstantType(StringConstant str, Span span) {
public static final class StringLiteralType extends Type {
public StringLiteralType(StringConstant str, Span span) {
super(span, List.of(str));
}
@Override
public <T> T accept(ParserVisitor<T> visitor) {
return visitor.visitStringConstantType(this);
return visitor.visitStringLiteralType(this);
}
public StringConstant getStr() {
@@ -1,5 +1,5 @@
/*
* Copyright © 2025 Apple Inc. and the Pkl project authors. All rights reserved.
* Copyright © 2025-2026 Apple Inc. and the Pkl project authors. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -38,6 +38,9 @@ public record FullSpan(
@Override
public String toString() {
if (lineBegin == lineEnd && colBegin == colEnd) {
return "(%d:%d)".formatted(lineBegin, colBegin);
}
return "(%d:%d - %d:%d)".formatted(lineBegin, colBegin, lineEnd, colEnd);
}
}
@@ -51,6 +51,10 @@ public final class Node {
return text;
}
public void setText(String text) {
this.text = text;
}
/** Returns the first child of type {@code type} or {@code null}. */
public @Nullable Node findChildByType(NodeType type) {
for (var child : children) {
@@ -16,13 +16,68 @@
package org.pkl.parser.syntax.generic;
public enum NodeType {
TERMINAL,
SHEBANG,
// affixes,
LINE_COMMENT(NodeKind.AFFIX),
BLOCK_COMMENT(NodeKind.AFFIX),
SEMICOLON(NodeKind.AFFIX),
// terminals: keywords
AMENDS_KEYWORD(NodeKind.TERMINAL),
AS_KEYWORD(NodeKind.TERMINAL),
CLASS_KEYWORD(NodeKind.TERMINAL),
ELSE_KEYWORD(NodeKind.TERMINAL),
EXTENDS_KEYWORD(NodeKind.TERMINAL),
FOR_KEYWORD(NodeKind.TERMINAL),
FUNCTION_KEYWORD(NodeKind.TERMINAL),
IF_KEYWORD(NodeKind.TERMINAL),
IMPORT_KEYWORD(NodeKind.TERMINAL),
IMPORT_STAR_KEYWORD(NodeKind.TERMINAL),
IN_KEYWORD(NodeKind.TERMINAL),
LET_KEYWORD(NodeKind.TERMINAL),
MODULE_KEYWORD(NodeKind.TERMINAL),
NEW_KEYWORD(NodeKind.TERMINAL),
OUT_KEYWORD(NodeKind.TERMINAL),
READ_KEYWORD(NodeKind.TERMINAL),
READ_QUESTION_KEYWORD(NodeKind.TERMINAL),
READ_STAR_KEYWORD(NodeKind.TERMINAL),
SUPER_KEYWORD(NodeKind.TERMINAL),
THROW_KEYWORD(NodeKind.TERMINAL),
TRACE_KEYWORD(NodeKind.TERMINAL),
TYPEALIAS_KEYWORD(NodeKind.TERMINAL),
WHEN_KEYWORD(NodeKind.TERMINAL),
// terminals: punctuation
ARROW(NodeKind.TERMINAL),
ASSIGN(NodeKind.TERMINAL),
AT(NodeKind.TERMINAL),
COLON(NodeKind.TERMINAL),
COMMA(NodeKind.TERMINAL),
DOT(NodeKind.TERMINAL),
GT(NodeKind.TERMINAL),
LBRACE(NodeKind.TERMINAL),
LBRACK(NodeKind.TERMINAL),
LPAREN(NodeKind.TERMINAL),
LPRED(NodeKind.TERMINAL),
LT(NodeKind.TERMINAL),
MINUS(NodeKind.TERMINAL),
NOT(NodeKind.TERMINAL),
QSPREAD(NodeKind.TERMINAL),
QUESTION(NodeKind.TERMINAL),
RBRACE(NodeKind.TERMINAL),
RBRACK(NodeKind.TERMINAL),
RPAREN(NodeKind.TERMINAL),
SPREAD(NodeKind.TERMINAL),
STAR(NodeKind.TERMINAL),
UNDERSCORE(NodeKind.TERMINAL),
UNION(NodeKind.TERMINAL),
// terminals: string delimiters
INTERPOLATION_START(NodeKind.TERMINAL),
STRING_START(NodeKind.TERMINAL),
STRING_MULTI_START(NodeKind.TERMINAL),
STRING_END(NodeKind.TERMINAL),
MODULE,
DOC_COMMENT,
DOC_COMMENT_LINE,
@@ -47,14 +102,14 @@ public enum NodeType {
CLASS_BODY,
CLASS_BODY_ELEMENTS,
CLASS_METHOD,
CLASS_METHOD_HEADER,
CLASS_METHOD_BODY,
METHOD_HEADER,
METHOD_BODY,
CLASS_PROPERTY,
CLASS_PROPERTY_HEADER,
CLASS_PROPERTY_HEADER_BEGIN,
CLASS_PROPERTY_BODY,
OBJECT_BODY,
OBJECT_MEMBER_LIST,
OBJECT_MEMBER_ELEMENTS,
PARAMETER,
TYPE_ANNOTATION,
PARAMETER_LIST,
@@ -67,7 +122,8 @@ public enum NodeType {
TYPE_ARGUMENT_LIST_ELEMENTS,
OBJECT_PARAMETER_LIST,
TYPE_PARAMETER,
STRING_CHARS,
STRING_CHARS(NodeKind.TERMINAL),
STRING_CONSTANT,
OPERATOR,
STRING_NEWLINE,
STRING_CONTINUATION,
@@ -81,6 +137,7 @@ public enum NodeType {
OBJECT_PROPERTY_BODY,
OBJECT_METHOD,
MEMBER_PREDICATE,
MEMBER_PREDICATE_HEADER,
OBJECT_ENTRY,
OBJECT_ENTRY_HEADER,
OBJECT_SPREAD,
@@ -107,7 +164,6 @@ public enum NodeType {
FUNCTION_LITERAL_EXPR(NodeKind.EXPR),
FUNCTION_LITERAL_BODY,
PARENTHESIZED_EXPR(NodeKind.EXPR),
PARENTHESIZED_EXPR_ELEMENTS,
SUPER_SUBSCRIPT_EXPR(NodeKind.EXPR),
SUPER_ACCESS_EXPR(NodeKind.EXPR),
SUBSCRIPT_EXPR(NodeKind.EXPR),
@@ -143,7 +199,7 @@ public enum NodeType {
PARENTHESIZED_TYPE_ELEMENTS,
DECLARED_TYPE(NodeKind.TYPE),
NULLABLE_TYPE(NodeKind.TYPE),
STRING_CONSTANT_TYPE(NodeKind.TYPE),
STRING_LITERAL_TYPE(NodeKind.TYPE),
CONSTRAINED_TYPE(NodeKind.TYPE),
CONSTRAINED_TYPE_CONSTRAINT,
CONSTRAINED_TYPE_ELEMENTS;
@@ -162,6 +218,10 @@ public enum NodeType {
return kind == NodeKind.AFFIX;
}
public boolean isTerminal() {
return kind == NodeKind.TERMINAL;
}
public boolean isExpression() {
return kind == NodeKind.EXPR;
}
@@ -174,6 +234,7 @@ public enum NodeType {
TYPE,
EXPR,
AFFIX,
TERMINAL,
NONE;
}
}
@@ -55,13 +55,13 @@ class GenericSexpRenderer(code: String) {
buf.append("(")
buf.append(name(node))
val oldTab = increaseTab()
var previousTerminal: Node? = null
var isDefault = false
for (child in node.children) {
if (child.type == NodeType.TERMINAL) previousTerminal = child
if (child.type in IGNORED_CHILDREN) continue
if (child.type == NodeType.STAR) isDefault = true
if (child.type.isIgnored()) continue
buf.append('\n')
if (previousTerminal != null && previousTerminal.text(source) == "*") {
previousTerminal = null
if (isDefault) {
isDefault = false
renderDefaultUnionType(child)
} else {
innerRender(child)
@@ -83,9 +83,9 @@ class GenericSexpRenderer(code: String) {
private fun collectChildren(node: Node): List<Node> =
when (node.type) {
NodeType.MULTI_LINE_STRING_LITERAL_EXPR ->
node.children.filter { it.type !in IGNORED_CHILDREN && !it.type.isStringData() }
node.children.filter { !it.type.isIgnored() && !it.type.isStringData() }
NodeType.SINGLE_LINE_STRING_LITERAL_EXPR -> {
val children = node.children.filter { it.type !in IGNORED_CHILDREN }
val children = node.children.filter { !it.type.isIgnored() }
val res = mutableListOf<Node>()
var prev: Node? = null
for (child in children) {
@@ -97,11 +97,13 @@ class GenericSexpRenderer(code: String) {
}
res
}
// a string constant is rendered as a single leaf
NodeType.STRING_CONSTANT,
NodeType.DOC_COMMENT -> listOf()
else -> {
val nodes = mutableListOf<Node>()
for (child in node.children) {
if (child.type in IGNORED_CHILDREN) continue
if (child.type.isIgnored()) continue
if (child.type in UNPACK_CHILDREN) {
nodes += collectChildren(child)
} else {
@@ -112,6 +114,9 @@ class GenericSexpRenderer(code: String) {
}
}
private fun NodeType.isIgnored(): Boolean =
this != NodeType.STRING_CHARS && (isTerminal || this in IGNORED_CHILDREN)
private fun NodeType.isStringData(): Boolean =
this == NodeType.STRING_CHARS || this == NodeType.STRING_ESCAPE
@@ -125,19 +130,18 @@ class GenericSexpRenderer(code: String) {
NodeType.EXTENDS_CLAUSE,
NodeType.AMENDS_CLAUSE -> "extendsOrAmendsClause"
NodeType.TYPEALIAS -> "typeAlias"
NodeType.STRING_CONSTANT,
NodeType.STRING_ESCAPE -> "stringChars"
NodeType.QUALIFIED_ACCESS_EXPR -> {
val op = node.findChildByType(NodeType.OPERATOR)!!
if (op.text(source) == ".") "qualifiedAccessExpr" else "nullableQualifiedAccessExpr"
}
NodeType.READ_EXPR -> {
val terminal = node.children.find { it.type == NodeType.TERMINAL }!!.text(source)
when (terminal) {
"read*" -> "readGlobExpr"
"read?" -> "readNullExpr"
NodeType.READ_EXPR ->
when {
node.findChildByType(NodeType.READ_STAR_KEYWORD) != null -> "readGlobExpr"
node.findChildByType(NodeType.READ_QUESTION_KEYWORD) != null -> "readNullExpr"
else -> "readExpr"
}
}
else -> {
val names = node.type.name.split('_').map { it.lowercase() }
if (names.size > 1) {
@@ -148,9 +152,9 @@ class GenericSexpRenderer(code: String) {
}
private fun importName(node: Node, isExpr: Boolean): String {
val terminal = node.children.find { it.type == NodeType.TERMINAL }!!.text(source)
val isGlob = node.findChildByType(NodeType.IMPORT_STAR_KEYWORD) != null
val suffix = if (isExpr) "Expr" else "Clause"
return if (terminal == "import*") "importGlob$suffix" else "import$suffix"
return if (isGlob) "importGlob$suffix" else "import$suffix"
}
private fun binopName(node: Node): String {
@@ -194,7 +198,6 @@ class GenericSexpRenderer(code: String) {
NodeType.BLOCK_COMMENT,
NodeType.SHEBANG,
NodeType.SEMICOLON,
NodeType.TERMINAL,
NodeType.OPERATOR,
NodeType.STRING_NEWLINE,
NodeType.STRING_CONTINUATION,
@@ -210,15 +213,16 @@ class GenericSexpRenderer(code: String) {
NodeType.CLASS_PROPERTY_HEADER,
NodeType.CLASS_PROPERTY_HEADER_BEGIN,
NodeType.CLASS_PROPERTY_BODY,
NodeType.CLASS_METHOD_HEADER,
NodeType.CLASS_METHOD_BODY,
NodeType.METHOD_HEADER,
NodeType.METHOD_BODY,
NodeType.CLASS_HEADER,
NodeType.CLASS_HEADER_EXTENDS,
NodeType.CLASS_BODY_ELEMENTS,
NodeType.MODIFIER_LIST,
NodeType.NEW_HEADER,
NodeType.OBJECT_MEMBER_LIST,
NodeType.OBJECT_MEMBER_ELEMENTS,
NodeType.OBJECT_ENTRY_HEADER,
NodeType.MEMBER_PREDICATE_HEADER,
NodeType.OBJECT_PROPERTY_HEADER,
NodeType.OBJECT_PROPERTY_HEADER_BEGIN,
NodeType.OBJECT_PROPERTY_BODY,
@@ -241,7 +245,6 @@ class GenericSexpRenderer(code: String) {
NodeType.TYPE_ARGUMENT_LIST_ELEMENTS,
NodeType.LET_PARAMETER_DEFINITION,
NodeType.LET_PARAMETER,
NodeType.PARENTHESIZED_EXPR_ELEMENTS,
NodeType.PARENTHESIZED_TYPE_ELEMENTS,
NodeType.FUNCTION_TYPE_PARAMETERS,
)
@@ -777,7 +777,7 @@ class SexpRenderer {
buf.append(tab)
buf.append("(thisType)")
}
is StringConstantType -> renderStringConstantType(type)
is StringLiteralType -> renderStringLiteralType(type)
is DeclaredType -> renderDeclaredType(type)
is ParenthesizedType -> renderParenthesizedType(type)
is NullableType -> renderNullableType(type)
@@ -787,9 +787,9 @@ class SexpRenderer {
}
}
fun renderStringConstantType(type: StringConstantType) {
fun renderStringLiteralType(type: StringLiteralType) {
buf.append(tab)
buf.append("(stringConstantType")
buf.append("(stringLiteralType")
val oldTab = increaseTab()
buf.append('\n')
renderStringConstant(type.str)