Add pkl:syntax stdlib module (#1821)
This commit is contained in:
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)
|
||||
|
||||
Reference in new issue
Block a user