Implement an error recovering tree parser

This is *heavily* based off of https://matklad.github.io/2023/05/21/resilient-ll-parsing-tutorial.html and https://github.com/rust-lang/rust-analyzer

Author: jaredlll08

.run/tests_gradle.run.xml

@@ -10,7 +10,7 @@
       </option>
       <option name="taskNames">
         <list>
-          <option value=":ScriptingExample:test" />
+          <option value=":test" />
         </list>
       </option>
       <option name="vmOptions" />

Parser/build.gradle

@@ -6,4 +6,15 @@ plugins {
 dependencies {
 	api project(':Shared')
 	api project(':CodeModel')
+	testImplementation libs.jupiter.api
+	testImplementation libs.junit.platform.engine
+	testRuntimeOnly libs.jupiter.engine
 }
+
+
+test {
+	useJUnitPlatform()
+	testLogging {
+		events "PASSED", "FAILED", "SKIPPED"
+	}
+}

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenSet.java

@@ -0,0 +1,45 @@
+package org.openzen.zenscript.lexer;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+public class ZSTokenSet {
+
+	private static final ZSTokenSet EMPTY = new ZSTokenSet(Collections.emptySet());
+
+	private final Set<ZSTokenType> tokens;
+
+	public static ZSTokenSet empty() {
+		return EMPTY;
+	}
+
+	public static ZSTokenSet of(ZSTokenType... tokens) {
+		return new ZSTokenSet(new HashSet<>(Arrays.asList(tokens)));
+	}
+
+	private ZSTokenSet(Set<ZSTokenType> tokens) {
+		this.tokens = tokens;
+	}
+
+	public ZSTokenSet and(ZSTokenType... newTokens) {
+		Set<ZSTokenType> tokens = new HashSet<>(this.tokens());
+		tokens.addAll(Arrays.asList(newTokens));
+		return new ZSTokenSet(tokens);
+	}
+
+	public ZSTokenSet without(ZSTokenType... removedTokens) {
+		Set<ZSTokenType> tokens = new HashSet<>(this.tokens());
+		Arrays.asList(removedTokens).forEach(tokens::remove);
+		return new ZSTokenSet(tokens);
+	}
+
+	public boolean contains(ZSTokenType token) {
+		return this.tokens().contains(token);
+	}
+
+	public Set<ZSTokenType> tokens() {
+		return tokens;
+	}
+}

Parser/src/main/java/org/openzen/zenscript/tree/Annotation.java

@@ -0,0 +1,29 @@
+package org.openzen.zenscript.tree;
+
+import org.openzen.zenscript.lexer.ZSTokenType;
+
+class Annotation {
+
+	//TODO TEST
+	static boolean parse(TreeParser p) {
+		boolean parsed = false;
+		while (p.at(ZSTokenType.T_SQOPEN)) {
+			if (p.nth(1) == ZSTokenType.T_IDENTIFIER) {
+				TreeParser.MarkOpened open = p.open();
+				p.expect(ZSTokenType.T_SQOPEN);
+				p.whitespace();
+				Type.parse(p);
+				p.whitespace();
+				CallArguments.parse(p);
+				p.whitespace();
+				p.expect(ZSTokenType.T_SQCLOSE);
+				p.close(open, TreeKind.ANNOTATION);
+				p.whitespace();
+				parsed = true;
+			} else {
+				break;
+			}
+		}
+		return parsed;
+	}
+}

Parser/src/main/java/org/openzen/zenscript/tree/CallArguments.java

@@ -0,0 +1,28 @@
+package org.openzen.zenscript.tree;
+
+import org.openzen.zenscript.lexer.ZSTokenType;
+
+class CallArguments {
+
+	static void parse(TreeParser p) {
+		if (p.at(ZSTokenType.T_BROPEN)) {
+			TreeParser.MarkOpened open = p.open();
+			p.expect(ZSTokenType.T_BROPEN);
+			p.whitespace();
+			if (!p.eat(ZSTokenType.T_BRCLOSE)) {
+				do {
+					// either eats nothing or eat for the comma
+					p.whitespace();
+					TreeParser.MarkOpened argumentOpen = p.open();
+					Expression.parse(p);
+					p.close(argumentOpen, TreeKind.CALL_ARGUMENT);
+				} while (p.eat(ZSTokenType.T_COMMA) && !p.eof());
+				p.expect(ZSTokenType.T_BRCLOSE);
+				p.whitespace();
+			}
+			p.whitespace();
+			p.close(open, TreeKind.CALL_ARGUMENTS);
+		}
+	}
+
+}

Parser/src/main/java/org/openzen/zenscript/tree/Child.java

@@ -0,0 +1,150 @@
+package org.openzen.zenscript.tree;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.lexer.ZSToken;
+import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.tree.lexer.PositionedToken;
+
+public interface Child {
+
+	static Child ofToken(PositionedToken<ZSTokenType, ZSToken> token) {
+		return new TokenChild(token);
+	}
+
+	static Child ofTree(Tree tree) {
+		return new TreeChild(tree);
+	}
+
+	static Child ofError(CodePosition position, String message) {
+		return new ErrorChild(position, message);
+	}
+
+	boolean isError();
+
+	boolean isToken();
+
+	boolean isTree();
+
+	PositionedToken<ZSTokenType, ZSToken> asToken();
+
+	Tree asTree();
+
+	ParseError asError();
+
+	class TokenChild implements Child {
+		private final PositionedToken<ZSTokenType, ZSToken> token;
+
+		private TokenChild(PositionedToken<ZSTokenType, ZSToken> token) {
+			this.token = token;
+		}
+
+		@Override
+		public boolean isError() {
+			return false;
+		}
+
+		@Override
+		public boolean isToken() {
+			return true;
+		}
+
+		@Override
+		public boolean isTree() {
+			return false;
+		}
+
+		@Override
+		public PositionedToken<ZSTokenType, ZSToken> asToken() {
+			return this.token;
+		}
+
+		@Override
+		public Tree asTree() {
+			throw new IllegalStateException("Unable to convert a token to a tree!");
+		}
+
+		@Override
+		public ParseError asError() {
+			throw new IllegalStateException("Unable to convert a token to an error	!");
+		}
+	}
+
+	class TreeChild implements Child {
+		private final Tree tree;
+
+		private TreeChild(Tree tree) {
+			this.tree = tree;
+		}
+
+		@Override
+		public boolean isError() {
+			return false;
+		}
+
+		@Override
+		public boolean isToken() {
+			return false;
+		}
+
+		@Override
+		public boolean isTree() {
+			return true;
+		}
+
+		@Override
+		public PositionedToken<ZSTokenType, ZSToken> asToken() {
+			throw new IllegalStateException("Unable to convert a tree to a token!");
+		}
+
+		@Override
+		public Tree asTree() {
+			return tree;
+		}
+
+		@Override
+		public ParseError asError() {
+			throw new IllegalStateException("Unable to convert a tree to an error!");
+		}
+	}
+
+	class ErrorChild implements Child {
+		private final CodePosition position;
+		private final String message;
+
+		public ErrorChild(CodePosition position, String message) {
+			this.position = position;
+			this.message = message;
+		}
+
+		@Override
+		public boolean isError() {
+			return true;
+		}
+
+		@Override
+		public boolean isToken() {
+			return false;
+		}
+
+		@Override
+		public boolean isTree() {
+			return false;
+		}
+
+		@Override
+		public PositionedToken<ZSTokenType, ZSToken> asToken() {
+			throw new IllegalStateException("Unable to convert an error to a token!");
+		}
+
+
+		@Override
+		public Tree asTree() {
+			throw new IllegalStateException("Unable to convert an error to a tree!");
+		}
+
+		@Override
+		public ParseError asError() {
+			return new ParseError(this.position, this.message);
+		}
+	}
+}