package slangc.parser;

public class Parse {
	private int maxRecursion = 1000;
	
	public String nodeTypesAsString(NodeType[] types) {
		if (types.length == 0) {
			return "Nothing?";
		} else if (types.length == 1) {
			return types[0].name();
		} else {
			String result = "";
			
			for (int i = 0; i < types.length; i++) {
				if (i != 0) {
					if (i == types.length - 1) {
						result += " or ";
					} else {
						result += ", ";
					}
				}
				
				result += types[i].name();
			}
			
			return result;
		}
	}
	
	public Node expectAny(ScanWalker walker, int recursion, NodeType... types) {
		return expectAnyArray(walker, recursion, types);
	}

	public Node expectAnyArray(ScanWalker walker, int recursion, NodeType[] types) {
		Node result = parseAnyArray(walker, recursion + 1, types);
		
		if (result == null) {
			result = new Branch(NodeType.ERROR_ONLY).annotate(ErrorType.EXPECTING, "Expecting " + nodeTypesAsString(types) + " (got " + walker.peek().getType().name() + ")");
		}
		
		return result;
	}
	
	public Node parseAny(ScanWalker walker, int recursion, NodeType... types) {
		return parseAnyArray(walker, recursion, types);
	}
	
	public Node parseAnyArray(ScanWalker walker, int recursion, NodeType[] types) {
		for (int i = 0; i < types.length; i++) {
			ScanWalker w = walker.clone();
			Node result = parseInner(w, recursion + 1, types[i]);
			if (result != null) {
				walker.reset(w);
                ScanWalker.recycle(w);
				return result;
			}
            ScanWalker.recycle(w);
		}
		return null;
	}
	
	public Node parseList(ScanWalker walker, int recursion, NodeType listType, NodeType separator, boolean consumeTailSeparator, NodeType... types) {
		return parseListArray(walker, recursion, listType, separator, consumeTailSeparator, types);
	}
	
	public Node parseListArray(ScanWalker walker, int recursion, NodeType listType, NodeType separator, boolean consumeTailSeparator, NodeType[] types) {
		checkRecursion(walker, recursion);
		Branch result = new Branch(listType);
		Node n;
		boolean first = true;
		
		do {
			ScanWalker w = walker.clone();
			if (first || separator == null) {
				n = parseAnyArray(w, recursion + 1, types);
				first = false;
			} else {
				ScanWalker w2 = w.clone();
				Node sep = parseInner(w2, recursion + 1, separator);
				if (sep == null) {
					n = null;
				} else {
					n = parseAnyArray(w2, recursion + 1, types);
					//System.out.println("Got a "+ n);
					if (n != null || consumeTailSeparator) {
						result.append(sep);
						w.reset(w2);
					}
				}
                ScanWalker.recycle(w2);
			}
			if (n != null) {
				result.append(n);
				walker.reset(w);
			} else if (consumeTailSeparator) {
				walker.reset(w);
			}
            ScanWalker.recycle(w);
		} while (n != null);
		
		return result;
	}
	
	public Node parseGenericOnlyList(ScanWalker walker, int recursion, NodeType listType, NodeType separator, boolean consumeTailSeparator, NodeType gentype, NodeType middletype) {
		checkRecursion(walker, recursion);
		Branch result = new Branch(listType);
		Node n;
		boolean first = true;
		
		Node lastGenType = null;
		ScanWalker lastGenWalker = null;
		ScanWalker ogWalker = walker.clone();
		int iter = 0;
		do {
			//System.out.println("XXXXXX" + iter); iter++;
			ScanWalker w = walker.clone();
			if (first || separator == null) {
				n = parseAny(w, recursion + 1, gentype, middletype);
				if (n != null && n.getNodeType() == gentype) {
					lastGenType = n;
					lastGenWalker = w.clone();
				}
				first = false;
			} else {
				ScanWalker w2 = w.clone();
				Node sep = parseInner(w2, recursion + 1, separator);
				if (sep == null) {
					n = null;
				} else {
					n = parseAny(w2, recursion + 1, gentype, middletype);
					if (n != null && n.getNodeType() == gentype) {
						lastGenType = n;
						lastGenWalker = w2.clone();
					}
					//System.out.println("Got a "+ n);
					if (n != null || consumeTailSeparator) {
						result.append(sep);
						w.reset(w2);
					}
				}
                ScanWalker.recycle(w2);
			}
			if (n != null) {
				result.append(n);
				walker.reset(w);
			} else if (consumeTailSeparator) {
				walker.reset(w);
			}
            ScanWalker.recycle(w);
		} while (n != null);
		
		if (lastGenWalker == null) {
			walker.reset(ogWalker);
			return null;
		} else {
			walker.reset(lastGenWalker);
			Branch realResult = new Branch(listType);
			for (int i = 0; i < result.countSubnodes(); i++) {
				realResult.append(result.getSubnode(i));
				if (result.getSubnode(i) == lastGenType) {
					return realResult;
				}
			}
			throw new Error("Internal error (this should be unreachable)");
		}
	}
	
	public Token parseToken(ScanWalker walker, int recursion, TokenType type) {
		//checkRecursion(walker, recursion);
		if (walker.isAtEnd()) {
			//System.out.println("AT END");
			return null;
		}
		if (walker.peek().is(type)) {
			//System.out.println("Got a match to " + type);
			Token result = walker.peek();
			walker.advance();
			return result;
		} else {
			//System.out.println("Not a " + type + " but a " + walker.peek());
			return null;
		}
	}
	
	public Token parseToken(ScanWalker walker, int recursion, TokenType type, String value) {
		//checkRecursion(walker, recursion);
		if (walker.isAtEnd()) {
			return null;
		}
		if (walker.peek().is(type, value)) {
			Token result = walker.peek();
			walker.advance();
			return result;
		} else {
			return null;
		}
	}
	
	public Token parseToken(ScanWalker walker, int recursion, Language.Key key) {
		//checkRecursion(walker, recursion);
		if (walker.isAtEnd()) {
			return null;
		}
		String val = walker.peek().getSnippet().getSource();
		if (walker.peek().is(TokenType.KEYWORD) && walker.getScan().getLanguage().matches(key, val)) {
			Token result = walker.peek();
			walker.advance();
			return result;
		} else {
			return null;
		}
	}
	
	public Token parseToken(ScanWalker walker, int recursion, String value) {
		// Can skip recursion check since we know we won't recurse from here! checkRecursion(walker, recursion);
		if (walker.isAtEnd()) {
			return null;
		}
		if (walker.peek().is(value)) {
			Token result = walker.peek();
			walker.advance();
			return result;
		} else {
			return null;
		}
	}
	
	public Branch parseTokenBranch(ScanWalker walker, int recursion, NodeType n, TokenType type) {
		Token t = parseToken(walker, recursion, type);
		//System.out.println("Got " + t);
		if (t == null) {
			return null;
		} else {
			return new Branch(n, t);
		}
	}
	
	public Branch parseTokenBranch(ScanWalker walker, int recursion, NodeType n, Language.Key key) {
		Token t = parseToken(walker, recursion, key);
		//System.out.println("Got " + t);
		if (t == null) {
			return null;
		} else {
			return new Branch(n, t);
		}
	}
	
	public Branch parseTokenBranch(ScanWalker walker, int recursion, NodeType n, TokenType type, String value) {
		Token t = parseToken(walker, recursion, type, value);
		if (t == null) {
			return null;
		} else {
			return new Branch(n, t);
		}
	}
	
	/** This one is used for the special >> and >>> operators (which are actually parsed as a sequence of > operators, to avoid
	 * conflict with nested template sizeExpression (e.g. Map<String,List<String>>). */
	public Branch parseSpecialTokenBranch(ScanWalker walker, int recursion, NodeType n, TokenType type, String value, int number) {
		ScanWalker pos = walker.clone();
		switch (number) { case 2: case 3: break; default: throw new Error("Internal error: Bad number " + number); }
		Token t = parseToken(walker, recursion, type, value);
		if (t == null) {
			walker.reset(pos);
            ScanWalker.recycle(pos);
			return null;
		} else {
			Token t2 = parseToken(walker, recursion, type, value);
			if (t2 == null) {
				walker.reset(pos);
                ScanWalker.recycle(pos);
				return null;
			} else if (number == 2) {
                ScanWalker.recycle(pos);
				return new Branch(n, t, t2);
			} else { // number == 3
				Token t3 = parseToken(walker, recursion, type, value);
				if (t3 == null) {
					walker.reset(pos);
                    ScanWalker.recycle(pos);
					return null;
				} else {
                    ScanWalker.recycle(pos);
					return new Branch(n, t, t2, t3);
				}
			}
		}
	}
	
	public Branch parseTokenBranch(ScanWalker walker, int recursion, NodeType n, String value) {
		Token t = parseToken(walker, recursion, value);
		if (t == null) {
			return null;
		} else {
			return new Branch(n, t);
		}
	}
	
	public Node parseSimpleBinop(ScanWalker walker, int recursion, NodeType result, NodeType operator, NodeType inner) {
		Node lhs = parseInner(walker, recursion + 1, inner);
		boolean done = false;
		while (lhs != null && !walker.isAtEnd() && !done) {
			Node op = parseInner(walker, recursion, operator);
			if (op == null) {
				done = true;
			} else {
				lhs = new Branch(result,
						lhs,
						op,
						expectAny(walker, recursion + 1, inner));
			}
		}
		return lhs;
	}
	
	public Node parseInner(ScanWalker walker, int recursion, NodeType type) {
		checkRecursion(walker, recursion);
		if (walker.isAtEnd()) {
			return null;
		}
		switch (type) {
		case NodeType.EOF:
			return parseTokenBranch(walker, recursion + 1, NodeType.EOF, TokenType.END_OF_FILE);
		case NodeType.TOKEN:
			if (walker.isAtEnd()) {
				return null;
			} else {
				Token t = walker.peek();
				walker.advance();
				return t;
			}
			
		case NodeType.NAME:
			//System.out.println("Parsing name...");
			return parseTokenBranch(walker, recursion + 1, NodeType.NAME, TokenType.NAME);
			
		case NodeType.INDEXED_NAME: {
			Node n = parseInner(walker, recursion + 1, NodeType.NAME);
			if (n == null) {
				return null;
			} else {
				Node o = parseInner(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE);
				if (o == null) {
					return n;
				} else {
					while (o != null) {
						Node c = expectAny(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE);
						n = new Branch(NodeType.INDEXED_NAME, n, o, c);
						// Check for next set of braces
						o = parseInner(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE);
					}
					return n;
				}
			}
		}
		
		case NodeType.GENERIC_NAME: {
			Node n = parseTokenBranch(walker, recursion + 1, NodeType.NAME, TokenType.NAME);
			if (n != null) {
				if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "<")) {
					Node genargs = parseAny(walker, recursion + 1, NodeType.GENERIC_ARGUMENTS);
					if (genargs == null) {
						return null;
					}
					return new Branch(NodeType.GENERIC_NAME, n, genargs);
				} else {
					return null;
				}
			}
			return null;
		}
		
		case NodeType.DOT:
			return parseTokenBranch(walker, recursion + 1, NodeType.DOT, TokenType.OPERATOR, ".");
			
		case NodeType.WILDCARD:
			return parseTokenBranch(walker, recursion + 1, NodeType.WILDCARD, TokenType.OPERATOR, "*");
			
		case NodeType.COMMA:
			return parseTokenBranch(walker, recursion + 1, NodeType.COMMA, TokenType.OPERATOR, ",");
			
		case NodeType.SEMICOLON:
			return parseTokenBranch(walker, recursion + 1, NodeType.SEMICOLON, TokenType.OPERATOR, ";");
			
		case NodeType.COLON:
			return parseTokenBranch(walker, recursion + 1, NodeType.COLON, TokenType.OPERATOR, ":");
			
		case NodeType.DOUBLECOLON:
			return parseTokenBranch(walker, recursion + 1, NodeType.DOUBLECOLON, TokenType.OPERATOR, "::");
			
		case NodeType.QUESTIONMARK:
			return parseTokenBranch(walker, recursion + 1, NodeType.QUESTIONMARK, TokenType.OPERATOR, "?");
			
		case NodeType.OPEN_ROUND_BRACE:
			return parseTokenBranch(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE, TokenType.OPERATOR, "(");
			
		case NodeType.CLOSE_ROUND_BRACE:
			return parseTokenBranch(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE, TokenType.OPERATOR, ")");
			
		case NodeType.OPEN_CURLY_BRACE:
			return parseTokenBranch(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE, TokenType.OPERATOR, "{");
			
		case NodeType.CLOSE_CURLY_BRACE:
			return parseTokenBranch(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE, TokenType.OPERATOR, "}");
			
		case NodeType.OPEN_SQUARE_BRACE:
			return parseTokenBranch(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE, TokenType.OPERATOR, "[");
			
		case NodeType.CLOSE_SQUARE_BRACE:
			return parseTokenBranch(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE, TokenType.OPERATOR, "]");
			
		case NodeType.OPEN_ANGLE_BRACE:
			return parseTokenBranch(walker, recursion + 1, NodeType.OPEN_ANGLE_BRACE, TokenType.OPERATOR, "<");
			
		case NodeType.CLOSE_ANGLE_BRACE:
			return parseTokenBranch(walker, recursion + 1, NodeType.CLOSE_ANGLE_BRACE, TokenType.OPERATOR, ">");
			
		case NodeType.PACKAGE_NAME:
			return parseList(walker, recursion + 1, NodeType.PACKAGE_NAME, NodeType.DOT, false, NodeType.NAME);
		
		case NodeType.PACKAGE_DECLARATION: {
				Token t = parseToken(walker, recursion + 1, Language.Key.MODULE); //TokenType.KEYWORD, "package");
				if (t == null) {
					return null;
				} else {
					return new Branch(NodeType.PACKAGE_DECLARATION,
							t,
							expectAny(walker, recursion + 1, NodeType.PACKAGE_NAME),
							expectAny(walker, recursion + 1, NodeType.SEMICOLON));
				}
			}
		
		case NodeType.IMPORTED_PACKAGE: {
			Node n = parseInner(walker, recursion + 1, NodeType.PACKAGE_NAME);
			if (n != null) {
				Node dot = parseInner(walker, recursion + 1, NodeType.DOT);
				if (dot != null) {
					return new Branch(NodeType.IMPORTED_PACKAGE,
							n,
							dot,
							expectAny(walker, recursion + 1, NodeType.WILDCARD));
				}
			}
			return null;
		}
		
		case NodeType.IMPORTED_TYPE:
			return parseList(walker, recursion + 1, NodeType.IMPORTED_TYPE, NodeType.DOT, false, NodeType.NAME);
			
		case NodeType.IMPORT_DECLARATION: {
				Token t = parseToken(walker, recursion + 1, Language.Key.IMPORT); //TokenType.KEYWORD, "import");
				if (t == null) {
					return null;
				} else {
					Token stat = parseToken(walker, recursion + 1, Language.Key.STATIC); //TokenType.KEYWORD, "static");
					if (stat == null) {
						return new Branch(NodeType.IMPORT_DECLARATION,
								t,
								expectAny(walker, recursion + 1, NodeType.IMPORTED_PACKAGE, NodeType.IMPORTED_TYPE),
								expectAny(walker, recursion + 1, NodeType.SEMICOLON));
					} else {
						return new Branch(NodeType.IMPORT_STATIC_DECLARATION,
								t,
								stat,
								expectAny(walker, recursion + 1, NodeType.IMPORTED_PACKAGE, NodeType.IMPORTED_TYPE),
								expectAny(walker, recursion + 1, NodeType.SEMICOLON));
					}
				}
			}
		
		case NodeType.TYPE_DECLARATIONS:
			return parseList(walker, recursion + 1, NodeType.TYPE_DECLARATIONS, null, false,
					NodeType.CLASS_DECLARATION,
					NodeType.INTERFACE_DECLARATION,
					NodeType.ENUM_DECLARATION,
					NodeType.ATTRIBUTE_DECLARATION,
					NodeType.SEMICOLON);

		case NodeType.INTERFACE_BASES: {
			Node keyword = parseToken(walker, recursion + 1, Language.Key.EXTENDS); //TokenType.KEYWORD, "extends");
			if (keyword == null) {
				return new Branch(NodeType.NO_INTERFACE_BASES);
			} else {
				return new Branch(NodeType.INTERFACE_BASES, keyword, parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCES));
			}
		}
		
		case NodeType.CLASS_BASE: {
			Node keyword = parseToken(walker, recursion + 1, Language.Key.EXTENDS); //TokenType.KEYWORD, "extends");
			if (keyword == null) {
				return new Branch(NodeType.NO_CLASS_BASE);
			} else {
				return new Branch(NodeType.CLASS_BASE, keyword, expectAny(walker, recursion + 1, NodeType.TYPE_REFERENCE));
			}
		}
		
		case NodeType.CLASS_IMPLEMENTS: {
			Node keyword = parseToken(walker, recursion + 1, Language.Key.IMPLEMENTS); //TokenType.KEYWORD, "implements");
			if (keyword == null) {
				return new Branch(NodeType.NO_CLASS_IMPLEMENTS);
			} else {
				return new Branch(NodeType.CLASS_IMPLEMENTS, keyword, parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCES));
			}
		}
		
		case NodeType.TYPE_REFERENCES:
			return parseList(walker, recursion + 1, NodeType.TYPE_REFERENCES, NodeType.COMMA, false, NodeType.TYPE_REFERENCE);

		case NodeType.TYPE_REFERENCE:
			if (!walker.isAtEnd() && walker.peek().is(TokenType.NAME)) { 
				return parseList(walker, recursion + 1, NodeType.TYPE_REFERENCE, NodeType.DOT, false, NodeType.GENERIC_NAME, NodeType.NAME);
			} else {
				return null;
			}
		
		case NodeType.GENERIC_ONLY_TYPE_REFERENCE:
			if (!walker.isAtEnd() && walker.peek().is(TokenType.NAME)) { 
				return parseGenericOnlyList(walker, recursion + 1, NodeType.TYPE_REFERENCE, NodeType.DOT, false, NodeType.GENERIC_NAME, NodeType.NAME);
			} else {
				return null;
			}
		
		case NodeType.TYPE: {
			Node result = null;
			result = result != null ? result : parseInner(walker, recursion + 1, NodeType.SIMPLE_TYPE);
			result = result != null ? result : parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCE);
			while (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "[") && walker.peekOffset(1) != null && walker.peekOffset(1).is(TokenType.OPERATOR, "]")) {
				result = new Branch(NodeType.ARRAY_TYPE,
						result,
						parseInner(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE),
						parseInner(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE));
			}
			if (result == null) {
				return null;
			} else {
				return new Branch(NodeType.TYPE, result);
			}
		}
		
		case NodeType.RETURN_TYPE: {
			Node voidToken = parseToken(walker, recursion + 1, Language.Key.VOID); //TokenType.KEYWORD, "void");
			if (voidToken == null) {
				Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
				if (t == null) {
					return null;
				} else {
					return new Branch(NodeType.RETURN_TYPE, t);
				}
			} else {
				return new Branch(NodeType.NO_RETURN_TYPE, voidToken);
			}
		}
		
		case NodeType.ENUM_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node keyword = parseToken(walker, recursion + 1, Language.Key.ENUM); //TokenType.KEYWORD, "enum");
			if (keyword == null) {
				return null;
			} else {
				return new Branch(NodeType.ENUM_DECLARATION,
						mods,
						keyword,
						expectAny(walker, recursion + 1, NodeType.NAME),
						parseInner(walker, recursion + 1, NodeType.GENERIC_DECLARATIONS),
						parseInner(walker, recursion + 1, NodeType.CLASS_BASE),
						parseInner(walker, recursion + 1, NodeType.CLASS_IMPLEMENTS),
						expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE),
						parseInner(walker, recursion + 1, NodeType.ENUM_MEMBERS),
						parseInner(walker, recursion + 1, NodeType.ENUM_CLASS_MEMBERS),
						expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
			}
		}
	
		case NodeType.INTERFACE_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node keyword = parseToken(walker, recursion + 1, Language.Key.INTERFACE); //TokenType.KEYWORD, "interface");
			if (keyword == null) {
				return null;
			} else {
				return new Branch(NodeType.INTERFACE_DECLARATION,
						mods,
						keyword,
						expectAny(walker, recursion + 1, NodeType.NAME),
						parseInner(walker, recursion + 1, NodeType.GENERIC_DECLARATIONS),
						parseInner(walker, recursion + 1, NodeType.INTERFACE_BASES),
						expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE),
						parseInner(walker, recursion + 1, NodeType.INTERFACE_MEMBERS),
						expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
			}
		}
		
		case NodeType.CLASS_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node keyword = parseToken(walker, recursion + 1, Language.Key.CLASS);//parseToken(walker, recursion + 1, TokenType.KEYWORD, "class");
			if (keyword == null) {
				return null;
			} else {
				return new Branch(NodeType.CLASS_DECLARATION,
						mods,
						keyword,
						expectAny(walker, recursion + 1, NodeType.NAME),
						parseInner(walker, recursion + 1, NodeType.GENERIC_DECLARATIONS),
						parseInner(walker, recursion + 1, NodeType.CLASS_BASE),
						parseInner(walker, recursion + 1, NodeType.CLASS_IMPLEMENTS),
						expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE),
						parseInner(walker, recursion + 1, NodeType.CLASS_MEMBERS),
						expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
			}
		}

		
		case NodeType.ATTRIBUTE_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node at = parseToken(walker, recursion + 1, TokenType.OPERATOR, "@");
			if (at == null) {
				return null;
			}
			Node keyword = parseToken(walker, recursion + 1, Language.Key.INTERFACE); //TokenType.KEYWORD, "interface");
			if (keyword == null) {
				return null;
			} else {
				return new Branch(NodeType.ATTRIBUTE_DECLARATION,
						mods,
						at,
						keyword,
						expectAny(walker, recursion + 1, NodeType.NAME),
						parseInner(walker, recursion + 1, NodeType.GENERIC_DECLARATIONS),
						parseInner(walker, recursion + 1, NodeType.INTERFACE_BASES),
						expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE),
						parseInner(walker, recursion + 1, NodeType.INTERFACE_MEMBERS),
						expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
			}
		}
		
		case NodeType.ENUM_MEMBERS:
			return parseList(walker, recursion + 1, NodeType.ENUM_MEMBERS, NodeType.COMMA, true, NodeType.SPECIALISED_ENUM_SUBTYPE, NodeType.SPECIALISED_ENUM_MEMBER, NodeType.ENUM_MEMBER);

		case NodeType.ENUM_MEMBER: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node name = parseToken(walker, recursion + 1, TokenType.NAME);
			if (name == null) {
				return null;
			} else {
				return new Branch(NodeType.ENUM_MEMBER, mods, name);
			}
		}
		
		case NodeType.SPECIALISED_ENUM_MEMBER: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node name = parseToken(walker, recursion + 1, TokenType.NAME);
			if (name == null) {
				return null;
			}
			Node args = parseAny(walker, recursion + 1, NodeType.ARGUMENTS);
			if (args == null) {
				return null;
			}
			return new Branch(NodeType.SPECIALISED_ENUM_MEMBER, mods, name, args);
		}
		
		case NodeType.SPECIALISED_ENUM_SUBTYPE: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node name = parseToken(walker, recursion + 1, TokenType.NAME);
			if (name == null) {
				return null;
			}
			Node args = parseAny(walker, recursion + 1, NodeType.ARGUMENTS);
			//if (args == null) {
			//	return null;
			//}
			Node open = parseAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE);
			if (open == null) {
				return null;
			}
			Node members = expectAny(walker, recursion + 1, NodeType.CLASS_MEMBERS);
			Node close = expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE);
			if (args == null) {
				return new Branch(NodeType.SPECIALISED_ENUM_SUBTYPE, mods, name, open, members, close);
			} else {
				return new Branch(NodeType.SPECIALISED_ENUM_SUBTYPE_WITH_ARGS, mods, name, args, open, members, close);
			}
		}
		
		case NodeType.ENUM_CLASS_MEMBERS: {
			//System.out.println("Looking for semicolon got " + walker.peek());
			Node semi = parseInner(walker, recursion + 1, NodeType.SEMICOLON);
			if (semi == null) {
				return new Branch(NodeType.NO_ENUM_CLASS_MEMBERS);
			} else {
				return new Branch(NodeType.ENUM_CLASS_MEMBERS, semi, parseInner(walker, recursion + 1, NodeType.CLASS_MEMBERS));
			}
		}
		
		case NodeType.CLASS_MEMBERS: {
			// Workaround because empty {...} seems to cause issues
			//ScanWalker pos = walker.clone();
			//Node emptyEnd = parseAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE);
			//if (emptyEnd != null) {
			//	walker.reset(pos);
			//	return new Branch(NodeType.CLASS_MEMBERS);
			//}
			return parseList(walker, recursion + 1, NodeType.CLASS_MEMBERS, null, false,
					NodeType.CONSTRUCTOR_DECLARATION,
					NodeType.STATIC_CONSTRUCTOR_DECLARATION,
					NodeType.METHOD_DECLARATION,
					NodeType.FIELD_DECLARATION,
					NodeType.CLASS_DECLARATION,
					NodeType.INTERFACE_DECLARATION,
					NodeType.ENUM_DECLARATION,
					NodeType.ATTRIBUTE_DECLARATION,
					NodeType.SEMICOLON);
		}
		
		case NodeType.INTERFACE_MEMBERS: {
			return parseList(walker, recursion + 1, NodeType.INTERFACE_MEMBERS, null, false,
					NodeType.STATIC_CONSTRUCTOR_DECLARATION,
					NodeType.METHOD_DECLARATION,
					NodeType.FIELD_DECLARATION,
					NodeType.CLASS_DECLARATION,
					NodeType.INTERFACE_DECLARATION,
					NodeType.ENUM_DECLARATION,
					NodeType.ATTRIBUTE_DECLARATION,
					NodeType.SEMICOLON);
		}
		
		case NodeType.MODIFIER_LIST:
			return parseList(walker, recursion + 1, NodeType.MODIFIER_LIST, null, false, NodeType.SIMPLE_MODIFIER, NodeType.COMPLEX_TAGGED_MODIFIER);
			
		case NodeType.SIMPLE_MODIFIER: {
			Node mod = null;
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.PUBLIC);//parseToken(walker, recursion + 1, TokenType.KEYWORD, "public");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.PROTECTED);//TokenType.KEYWORD, "protected");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.PRIVATE);//TokenType.KEYWORD, "private");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.STATIC);//TokenType.KEYWORD, "static");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.FINAL);//TokenType.KEYWORD, "final");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.ABSTRACT);//TokenType.KEYWORD, "abstract");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.SYNCHRONISED);//TokenType.KEYWORD, "synchronized");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.NATIVE);//TokenType.KEYWORD, "native");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.TRANSIENT);//TokenType.KEYWORD, "transient");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.VOLATILE);//TokenType.KEYWORD, "volatile");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.COMPAT_STRICTFP);//TokenType.KEYWORD, "strictfp");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.VOLATILE);//TokenType.KEYWORD, "volatile");
			mod = mod != null ? mod : parseToken(walker, recursion + 1, Language.Key.DEFAULT);//TokenType.KEYWORD, "default");
			return mod == null ? null : new Branch(NodeType.SIMPLE_MODIFIER, mod);
		}
		
		case NodeType.BREAK_STATEMENT: {
			Node br = parseToken(walker, recursion + 1, Language.Key.BREAK); //TokenType.KEYWORD, "break");
			if (br == null) {
				return null;
			} else {
				Node label = parseAny(walker, recursion + 1, NodeType.NAME);
				Node semicolon = expectAny(walker, recursion + 1, NodeType.SEMICOLON);
				if (label == null) {
					return new Branch(NodeType.BREAK_STATEMENT, br, semicolon);
				} else {
					return new Branch(NodeType.BREAK_TO_STATEMENT, br, label, semicolon);
				}
			}
		}
		
		case NodeType.CONTINUE_STATEMENT: {
			Node br = parseToken(walker, recursion + 1, Language.Key.CONTINUE); //TokenType.KEYWORD, "continue");
			if (br == null) {
				return null;
			} else {
				Node label = parseAny(walker, recursion + 1, NodeType.NAME);
				Node semicolon = expectAny(walker, recursion + 1, NodeType.SEMICOLON);
				if (label == null) {
					return new Branch(NodeType.CONTINUE_STATEMENT, br, semicolon);
				} else {
					return new Branch(NodeType.CONTINUE_TO_STATEMENT, br, label, semicolon);
				}
			}
		}
		
		case NodeType.LABEL_STATEMENT: {
			Node n = parseAny(walker, recursion + 1, NodeType.NAME);
			if (n == null) {
				return null;
			}
			Node s = parseAny(walker, recursion + 1, NodeType.COLON);
			if (s == null) {
				return null;
			} else {
				return new Branch(NodeType.LABEL_STATEMENT, n, s);
			}
		}
		
		case NodeType.COMPLEX_TAGGED_MODIFIER: {
			Node tagsymbol = parseToken(walker, recursion + 1, TokenType.OPERATOR, "@");
			boolean noAt = (tagsymbol == null);
			if (noAt) {
				tagsymbol = tagsymbol != null ? tagsymbol : parseToken(walker, recursion + 1, TokenType.OPERATOR, "#");
				tagsymbol = tagsymbol != null ? tagsymbol : parseToken(walker, recursion + 1, TokenType.OPERATOR, "##");
			}
			if (tagsymbol == null) {
				return null;
			}
			Node tagname;
			if (noAt) {
				tagname = parseAny(walker, recursion + 1, NodeType.NAME, NodeType.STRING_LITERAL_EXPRESSION, NodeType.INTEGER_LITERAL_EXPRESSION);
			} else {
				tagname = parseAny(walker, recursion + 1, NodeType.TYPE_REFERENCE);
			}
			if (tagname == null) {
				return null;
			}
			if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "(")) {
				return new Branch(NodeType.COMPLEX_TAGGED_MODIFIER, tagsymbol, tagname, expectAny(walker, recursion + 1, NodeType.MODIFIER_ARGUMENTS));
			} else if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, ":")) {
				Node sep = parseToken(walker, recursion + 1, TokenType.OPERATOR, ":");
				return new Branch(NodeType.NAME_TAGGED_MODIFIER, tagsymbol, tagname, sep, expectAny(walker, recursion + 1,  NodeType.NAME, NodeType.STRING_LITERAL_EXPRESSION, NodeType.INTEGER_LITERAL_EXPRESSION));
			} else {
				return new Branch(NodeType.SIMPLE_TAGGED_MODIFIER, tagsymbol, tagname);
			}
		}
		
		case NodeType.MODIFIER_ARGUMENTS: {
			Node open = parseAny(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
			if (open == null) {
				return null;
			}
			Node inner = parseAny(walker, recursion + 1, NodeType.MODIFIER_EXPRESSIONS);
			Node close = expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE);
			return new Branch(NodeType.MODIFIER_ARGUMENTS, open, inner, close);
		}
		
		case NodeType.SIMPLE_TYPE: {
			Node result = null;
			result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.BIT); //TokenType.KEYWORD, "boolean");
			result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.BYTE); //TokenType.KEYWORD, "byte");
			result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.SHORT); //TokenType.KEYWORD, "short");
			result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.COMPAT_CHAR); //TokenType.KEYWORD, "char");
			result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.INT); //TokenType.KEYWORD, "int");
			result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.LONG); //TokenType.KEYWORD, "long");
			result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.FLOAT); //TokenType.KEYWORD, "float");
			result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.DOUBLE); //TokenType.KEYWORD, "double");
			//result = result != null ? result : parseToken(walker, recursion + 1, TokenType.KEYWORD, "cpuword");
			result = result != null ? result : parseToken(walker, recursion + 1, Language.Key.DUCK); //TokenType.KEYWORD, "duck");
			return result;
		}
		
		case NodeType.ARGUMENT_DECLARATIONS: {
			Node start = parseInner(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
			if (start == null) {
				return null;
			} else {
				return new Branch(NodeType.ARGUMENT_DECLARATIONS,
						start,
						parseList(walker, recursion + 1, NodeType.ARGUMENT_DECLARATION_LIST, NodeType.COMMA, false, NodeType.LAZY_ARGUMENT_DECLARATION, NodeType.VARIABLE_ARGUMENT_DECLARATION, NodeType.SIMPLE_ARGUMENT_DECLARATION),
						expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE));
			}
		}
		
		case NodeType.GENERIC_DECLARATIONS: {
			Node start = parseInner(walker, recursion + 1, NodeType.OPEN_ANGLE_BRACE);
			if (start == null) {
				return new Branch(NodeType.NO_GENERIC_DECLARATIONS);
			} else {
				return new Branch(NodeType.GENERIC_DECLARATIONS,
						start,
						parseList(walker, recursion + 1, NodeType.GENERIC_DECLARATION_LIST, NodeType.COMMA, false,
								NodeType.VARIABLE_TYPED_GENERIC_DECLARATION,
								NodeType.VARIABLE_GENERIC_DECLARATION,
								NodeType.SIMPLE_TYPED_GENERIC_DECLARATION,
								NodeType.SIMPLE_EXTENDED_GENERIC_DECLARATION,
								NodeType.SIMPLE_GENERIC_DECLARATION),
						expectAny(walker, recursion + 1, NodeType.CLOSE_ANGLE_BRACE));
			}
		}
		
		case NodeType.METHOD_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node gentype = parseInner(walker, recursion + 1, NodeType.GENERIC_DECLARATIONS);
			Node t = parseInner(walker, recursion + 1, NodeType.RETURN_TYPE);
			if (t == null) {
				return null;
			} else {
				Node n = parseInner(walker, recursion + 1, NodeType.NAME);
				if (n == null) {
					return null;
				} else {
					Node args = parseInner(walker, recursion + 1, NodeType.ARGUMENT_DECLARATIONS);
					if (args == null) {
						return null;
					} else {
						return new Branch(NodeType.METHOD_DECLARATION,
								mods,
								gentype,
								t,
								n,
								args,
								parseAny(walker, recursion + 1, NodeType.ARRAY_TYPE_TAIL),
								parseInner(walker, recursion + 1, NodeType.THROWS),
								expectAny(walker, recursion + 1, NodeType.METHOD_BODY));
					}
				}
			}
		}
		
		case NodeType.CONSTRUCTOR_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node n = parseInner(walker, recursion + 1, NodeType.NAME);
			if (n == null) {
				return null;
			} else {
				Node args = parseInner(walker, recursion + 1, NodeType.ARGUMENT_DECLARATIONS);
				if (args == null) {
					return null;
				} else {
					return new Branch(NodeType.CONSTRUCTOR_DECLARATION,
							mods,
							n,
							args,
							parseInner(walker, recursion + 1, NodeType.THROWS),
							expectAny(walker, recursion + 1, NodeType.METHOD_BODY));
				}
			}
		}
		
		case NodeType.STATIC_CONSTRUCTOR_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			if (walker.peek().is(TokenType.OPERATOR, "{")) {
				Node body = parseInner(walker, recursion + 1, NodeType.METHOD_BODY);
				return new Branch(NodeType.STATIC_CONSTRUCTOR_DECLARATION, mods, body);
			} else {
				return null;
			}
		}
		
		case NodeType.THROWS: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.THROWS); //TokenType.KEYWORD, "throws");
			if (keyword == null) {
				return new Branch(NodeType.NO_THROWS);
			} else {
				return new Branch(NodeType.THROWS, parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCES));
			}
		}
		
		case NodeType.METHOD_BODY: {
			Node semi = parseInner(walker, recursion + 1, NodeType.SEMICOLON);
			if (semi == null) {
				Node def = parseToken(walker, recursion + 1, Language.Key.DEFAULT); //TokenType.KEYWORD, "default");
				if (def != null) {
					return new Branch(NodeType.DEFAULT_METHOD_BODY,
							def,
							expectAny(walker, recursion + 1, NodeType.EXPRESSION),
							expectAny(walker, recursion + 1, NodeType.SEMICOLON));
				}
				return new Branch(NodeType.METHOD_BODY, expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT));
			} else {
				return new Branch(NodeType.NO_METHOD_BODY, semi);
			}
		}
		
		case NodeType.BLOCK_STATEMENT: {
			Node start = parseInner(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE);
			if (start == null) {
				return null;
			} else {
				return new Branch(NodeType.BLOCK_STATEMENT,
						start,
						parseInner(walker, recursion + 1, NodeType.STATEMENTS),
						expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
			}
		}
		
		case NodeType.SWITCH_STATEMENT: {
			Node keyword = parseToken(walker, recursion + 1, Language.Key.SWITCH); //TokenType.KEYWORD, "switch");
			if (keyword == null) {
				return null;
			}
			Node cond = expectAny(walker, recursion + 1, NodeType.BRACED_EXPRESSION);
			Node start = expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE);
			return new Branch(NodeType.SWITCH_STATEMENT,
					keyword,
					cond,
					start,
					parseInner(walker, recursion + 1, NodeType.SWITCH_MEMBERS),
					expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
		}
		
		case NodeType.ASSERT_STATEMENT: {
			Node keyword = parseToken(walker, recursion + 1, Language.Key.ASSERT); //TokenType.KEYWORD, "assert");
			if (keyword == null) {
				return null;
			} else {
				Node expr = expectAny(walker, recursion + 1, NodeType.EXPRESSION);
				Node colon = parseAny(walker, recursion + 1, NodeType.COLON);
				if (colon == null) {
					return new Branch(NodeType.ASSERT_STATEMENT,
							keyword,
							expr,
							expectAny(walker, recursion + 1, NodeType.SEMICOLON));
				} else {
					return new Branch(NodeType.ASSERT_DEBUG_STATEMENT,
							keyword,
							expr,
							colon,
							expectAny(walker, recursion + 1, NodeType.EXPRESSION),
							expectAny(walker, recursion + 1, NodeType.SEMICOLON));
				}
			}
		}
		
		case NodeType.THROW_STATEMENT: {
			Node keyword = parseToken(walker, recursion + 1, Language.Key.THROW); //TokenType.KEYWORD, "throw");
			if (keyword == null) {
				return null;
			} else {
				return new Branch(NodeType.THROW_STATEMENT,
						keyword,
						expectAny(walker, recursion + 1, NodeType.EXPRESSION),
						expectAny(walker, recursion + 1, NodeType.SEMICOLON));
			}
		}
		
		case NodeType.RETURN_EXPRESSION_STATEMENT: {
			Node keyword = parseToken(walker, recursion + 1, Language.Key.RETURN); //TokenType.KEYWORD, "return");
			if (keyword == null) {
				return null;
			} else {
				Node next = expectAny(walker, recursion + 1, NodeType.EXPRESSION, NodeType.SEMICOLON);
				if (next.getNodeType() == NodeType.SEMICOLON) {
					return new Branch(NodeType.RETURN_NOTHING_STATEMENT, keyword, next);
				} else {
					return new Branch(NodeType.RETURN_EXPRESSION_STATEMENT,
							keyword,
							next,
							expectAny(walker, recursion + 1, NodeType.SEMICOLON));
				}
			}
		}
		
		case NodeType.VARIABLE_STATEMENT: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
			if (t != null &&!walker.isAtEnd() && walker.peek().is(TokenType.NAME)) {
				return new Branch(NodeType.VARIABLE_STATEMENT,
						mods,
						t,
						parseInner(walker, recursion + 1, NodeType.SLOTS),
						expectAny(walker, recursion + 1, NodeType.SEMICOLON));
			} else {
				return null;
			}
		}
		
		case NodeType.FOR_VARIABLES: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
			if (t != null &&!walker.isAtEnd() && walker.peek().is(TokenType.NAME)) {
				return new Branch(NodeType.FOR_VARIABLES,
						mods,
						t,
						parseInner(walker, recursion + 1, NodeType.SLOTS));
			} else {
				return null;
			}
		}
		
		case NodeType.IF_STATEMENT: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.IF); //TokenType.KEYWORD, "if");
			if (keyword == null) {
				return null;
			} else {
				Node cond = expectAny(walker, recursion + 1, NodeType.BRACED_EXPRESSION); // TODO: Change to only bracketed expression
				Node cons = expectAny(walker, recursion + 1, NodeType.STATEMENT);
				Node els = parseInner(walker, recursion + 1, NodeType.ELSE_CLAUSE);
				return new Branch(NodeType.IF_STATEMENT, keyword, cond, cons, els);
			}
		}
		
		case NodeType.SYNCHRONIZED_STATEMENT: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.SYNCHRONISED); //TokenType.KEYWORD, "synchronized");
			if (keyword == null) {
				return null;
			} else {
				Node cond = expectAny(walker, recursion + 1, NodeType.BRACED_EXPRESSION); // TODO: Change to only bracketed expression
				Node cons = expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT);
				return new Branch(NodeType.SYNCHRONIZED_STATEMENT, keyword, cond, cons);
			}
		}
		
		case NodeType.ELSE_CLAUSE: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.ELSE); //TokenType.KEYWORD, "else");
			if (keyword == null) {
				return new Branch(NodeType.NO_ELSE_CLAUSE);
			} else {
				return new Branch(NodeType.ELSE_CLAUSE, keyword,
						expectAny(walker, recursion + 1, NodeType.STATEMENT));
			}
		}

		case NodeType.WHILE_STATEMENT: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.WHILE); //TokenType.KEYWORD, "while");
			if (keyword == null) {
				return null;
			} else {
				Node cond = expectAny(walker, recursion + 1, NodeType.BRACED_EXPRESSION);
				Node cons = expectAny(walker, recursion + 1, NodeType.STATEMENT, NodeType.SEMICOLON);
				return new Branch(NodeType.WHILE_STATEMENT, keyword, cond, cons);
			}
		}
		
		case NodeType.FOR_STATEMENT: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.FOR); //TokenType.KEYWORD, "for");
			if (keyword == null) {
				return null;
			} else {
				Node obr = expectAny(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
				Node st1 = expectAny(walker, recursion + 1, NodeType.FOR_VARIABLES, NodeType.EXPRESSIONS);
				Node firstsep = expectAny(walker, recursion + 1, NodeType.SEMICOLON, NodeType.COLON);
				if (firstsep.getNodeType() == NodeType.COLON) {
					// Handle for-each variant
					Node rangeexpr = parseAny(walker, recursion + 1, NodeType.EXPRESSIONS);
					Node cbr = expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE);
					Node cons = expectAny(walker, recursion + 1, NodeType.STATEMENT, NodeType.SEMICOLON);
					return new Branch(NodeType.FOR_EACH_STATEMENT, keyword, obr, st1, firstsep, rangeexpr, cbr, cons);
				} else {
					Node st2 = expectAny(walker, recursion + 1, NodeType.EXPRESSIONS);
					Node lastsep = expectAny(walker, recursion + 1, NodeType.SEMICOLON);
					Node st3 = parseAny(walker, recursion + 1, NodeType.EXPRESSIONS);
					Node cbr = expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE);
					Node cons = expectAny(walker, recursion + 1, NodeType.STATEMENT, NodeType.SEMICOLON);
					return new Branch(NodeType.FOR_STATEMENT, keyword, obr, st1, firstsep, st2, lastsep, st3, cbr, cons);
				}
			}
		}
		
		case NodeType.DO_WHILE_STATEMENT: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.DO); //TokenType.KEYWORD, "do");
			if (keyword == null) {
				return null;
			} else {
				Node cons = expectAny(walker, recursion + 1, NodeType.STATEMENT);
				Node kw2 = parseToken(walker, recursion + 1, Language.Key.WHILE); //TokenType.KEYWORD, "while");
				Node cond = expectAny(walker, recursion + 1, NodeType.BRACED_EXPRESSION);
				Node end = expectAny(walker, recursion + 1, NodeType.SEMICOLON);
				
				return new Branch(NodeType.DO_WHILE_STATEMENT, keyword, cons, kw2, cond, end);
			}
		}
		
		case NodeType.TRY_STATEMENT: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.TRY); //TokenType.KEYWORD, "try");
			if (keyword == null) {
				return null;
			} else {
				Node vars = parseAny(walker, recursion + 1, NodeType.TRY_RESOURCES);
				Node tries = expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT);
				Node catches = parseList(walker, recursion + 1, NodeType.CATCH_CLAUSES, null, false, NodeType.CATCH_CLAUSE);
				Node fin = parseInner(walker, recursion + 1, NodeType.FINALLY_CLAUSE);
				return new Branch(NodeType.TRY_STATEMENT, keyword, vars, tries, catches, fin);
			}
		}
		
		case NodeType.TRY_RESOURCES: {
			Node open = parseAny(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
			if (open == null) {
				return new Branch(NodeType.NO_TRY_RESOURCES);
			}
			return new Branch(NodeType.TRY_RESOURCES,
					open,
					parseList(walker, recursion + 1, NodeType.TRY_RESOURCE_LIST, NodeType.SEMICOLON, false, NodeType.FOR_VARIABLES),
					expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE));
		}
		
		case NodeType.CATCH_CLAUSE: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.CATCH); //TokenType.KEYWORD, "catch");
			if (keyword == null) {
				return null;
			} else {
				Node cond = expectAny(walker, recursion + 1, NodeType.ARGUMENT_DECLARATIONS);
				Node cons = expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT);
				return new Branch(NodeType.CATCH_CLAUSE, keyword, cond, cons);
			}
		}
		
		case NodeType.FINALLY_CLAUSE: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.FINALLY); //TokenType.KEYWORD, "finally");
			if (keyword == null) {
				return new Branch(NodeType.NO_FINALLY_CLAUSE);
			} else {
				Node cons = expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT);
				return new Branch(NodeType.FINALLY_CLAUSE, keyword, cons);
			}
		}
		
		case NodeType.EXPRESSION_STATEMENT: {
			Node expr = parseAny(walker, recursion + 1, NodeType.EXPRESSION);
			
			if (expr != null) {
				/*switch (expr.getNodeType()) {
				case NodeType.ASSIGNMENT_EXPRESSION:
				case NodeType.COUNT_EXPRESSION:
				case NodeType.AUTOMATIC_METHOD_CALL_EXPRESSION:
				case NodeType.NORMAL_METHOD_CALL_EXPRESSION:
				case NodeType.SUPER_CONSTRUCTOR_CALL_EXPRESSION:
				case NodeType.SUPER_METHOD_CALL_EXPRESSION:
				case NodeType.THIS_CONSTRUCTOR_CALL_EXPRESSION:
					return new Branch(NodeType.EXPRESSION_STATEMENT,
							expr,
							expectAny(walker, recursion + 1, NodeType.SEMICOLON));
				default:
					return null;
				}*/
				return new Branch(NodeType.EXPRESSION_STATEMENT,
						expr,
						expectAny(walker, recursion + 1, NodeType.SEMICOLON));
			} else {
				return null;
			}
		}
		
		case NodeType.STATEMENTS:
			return parseList(walker, recursion + 1, NodeType.STATEMENTS, null, false, NodeType.STATEMENT);
			
		case NodeType.SWITCH_MEMBERS:
			return parseList(walker, recursion + 1, NodeType.SWITCH_MEMBERS, null, false, NodeType.CASE_LABEL, NodeType.DEFAULT_LABEL, NodeType.STATEMENT);
		
		case NodeType.CASE_LABEL: {
			Node keyword = parseToken(walker, recursion + 1, Language.Key.CASE); //TokenType.KEYWORD, "case");
			if (keyword == null) {
				return null;
			} else {
				return new Branch(NodeType.CASE_LABEL,
						keyword,
						expectAny(walker, recursion + 1, NodeType.EXPRESSION),
						expectAny(walker, recursion + 1, NodeType.COLON));
			}
		}

		case NodeType.DEFAULT_LABEL: {
			Node keyword = parseToken(walker, recursion + 1, Language.Key.DEFAULT); //TokenType.KEYWORD, "default");
			if (keyword == null) {
				return null;
			} else {
				return new Branch(NodeType.DEFAULT_LABEL,
						keyword,
						expectAny(walker, recursion + 1, NodeType.COLON));
			}
		}
			
		case NodeType.STATEMENT:
			return parseAny(walker, recursion + 1,
					NodeType.LABEL_STATEMENT,
					NodeType.IF_STATEMENT,
					NodeType.WHILE_STATEMENT,
					NodeType.DO_WHILE_STATEMENT,
					NodeType.FOR_STATEMENT,
					NodeType.SWITCH_STATEMENT,
					NodeType.ASSERT_STATEMENT,
					NodeType.THROW_STATEMENT,
					NodeType.RETURN_EXPRESSION_STATEMENT,
					NodeType.TRY_STATEMENT,
					NodeType.VARIABLE_STATEMENT,
					NodeType.BLOCK_STATEMENT,
					NodeType.EXPRESSION_STATEMENT,
					NodeType.SYNCHRONIZED_STATEMENT,
					NodeType.BREAK_STATEMENT,
					NodeType.CONTINUE_STATEMENT,
					NodeType.CLASS_DECLARATION,
					NodeType.INTERFACE_DECLARATION,
					NodeType.ENUM_DECLARATION,
					NodeType.ATTRIBUTE_DECLARATION,
					NodeType.SEMICOLON);
		
		case NodeType.FIELD_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
			if (t != null &&!walker.isAtEnd() && walker.peek().is(TokenType.NAME)) {
				return new Branch(NodeType.FIELD_DECLARATION,
						mods,
						t,
						parseInner(walker, recursion + 1, NodeType.SLOTS),
						expectAny(walker, recursion + 1, NodeType.SEMICOLON));
			} else {
				return null;
			}
		}
		
		case NodeType.NULL_LITERAL_EXPRESSION: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.NULL); //TokenType.KEYWORD, "null");
			if (keyword == null) {
				return null;
			} else {
				return new Branch(NodeType.NULL_LITERAL_EXPRESSION, keyword);
			}
		}
		
		case NodeType.BOOLEAN_LITERAL_EXPRESSION: {
			Token keyword = parseToken(walker, recursion + 1, Language.Key.FALSE); //TokenType.KEYWORD, "false");
			if (keyword == null) {
				keyword = parseToken(walker, recursion + 1, Language.Key.TRUE); //TokenType.KEYWORD, "true");
			}
			if (keyword == null) {
				return null;
			} else {
				return new Branch(NodeType.BOOLEAN_LITERAL_EXPRESSION, keyword);
			}
		}
		
		case NodeType.INTEGER_LITERAL_EXPRESSION: {
			Token num = parseToken(walker, recursion + 1, TokenType.DEC_INTEGER);
			if (num == null) {
				num = parseToken(walker, recursion + 1, TokenType.HEX_INTEGER);
			}
			if (num == null) {
				num = parseToken(walker, recursion + 1, TokenType.BIN_INTEGER);
			}
			
			if (num == null) {
				return null;
			} else {
				return new Branch(NodeType.INTEGER_LITERAL_EXPRESSION, num);
			}
		}
		
		case NodeType.FLOAT_LITERAL_EXPRESSION: {
			Token num = parseToken(walker, recursion + 1, TokenType.DEC_FLOAT);
			if (num == null) {
				num = parseToken(walker, recursion + 1, TokenType.HEX_FLOAT);
			}
			if (num == null) {
				num = parseToken(walker, recursion + 1, TokenType.BIN_FLOAT);
			}
			if (num == null) {
				return null;
			} else {
				return new Branch(NodeType.FLOAT_LITERAL_EXPRESSION, num);
			}
		}
		
		case NodeType.STRING_LITERAL_EXPRESSION: {
			Token str = parseToken(walker, recursion + 1, TokenType.STRING);
			if (str == null) {
				return null;
			} else {
				return new Branch(NodeType.STRING_LITERAL_EXPRESSION, str);
			}
		}
		
		case NodeType.CHAR_LITERAL_EXPRESSION: {
			Token chr = parseToken(walker, recursion + 1, TokenType.CHAR);
			if (chr == null) {
				return null;
			} else {
				return new Branch(NodeType.CHAR_LITERAL_EXPRESSION, chr);
			}
		}
		
		case NodeType.LITERAL_EXPRESSION:
			return parseAny(walker, recursion + 1,
					NodeType.NULL_LITERAL_EXPRESSION,
					NodeType.BOOLEAN_LITERAL_EXPRESSION,
					NodeType.INTEGER_LITERAL_EXPRESSION,
					NodeType.FLOAT_LITERAL_EXPRESSION,
					NodeType.CHAR_LITERAL_EXPRESSION,
					NodeType.STRING_LITERAL_EXPRESSION);

		case NodeType.REFERENCE_EXPRESSION:
			return parseTokenBranch(walker, recursion + 1, NodeType.REFERENCE_EXPRESSION, TokenType.NAME);
			
		case NodeType.GENERIC_REFERENCE_EXPRESSION: {
			Node n = parseAny(walker, recursion + 1, NodeType.GENERIC_ONLY_TYPE_REFERENCE);
			if (n == null) {
				return null;
			}
			return new Branch(NodeType.GENERIC_REFERENCE_EXPRESSION, n);
		}
		
		case NodeType.GENERIC_REFERENCE_NAME: {
			Node args = parseAny(walker, recursion + 1, NodeType.GENERIC_ARGUMENTS);
			if (args == null) {
				return null;
			}
			Node nam = parseAny(walker, recursion + 1, NodeType.NAME);
			if (nam == null) {
				return null;
			}
			return new Branch(NodeType.GENERIC_NAME, args, nam);
		}
			
		case NodeType.SUPER:
			return parseTokenBranch(walker, recursion + 1, NodeType.SUPER, Language.Key.SUPER); //TokenType.KEYWORD, "super");
			
		case NodeType.THIS_EXPRESSION: {
			// TODO: Why'd I put this here?
			// Node t = parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCE);
			return parseTokenBranch(walker, recursion + 1, NodeType.THIS_EXPRESSION, Language.Key.THIS); //TokenType.KEYWORD, "this");
		}
		
		case NodeType.OUTER_THIS_EXPRESSION: {
			Node t = parseInner(walker, recursion + 1, NodeType.TYPE_REFERENCE);
			if (t == null) {
				return null;
			}
			Node dot = parseInner(walker, recursion + 1, NodeType.DOT);
			if (dot == null) {
				return null;
			}
			Node thi = parseTokenBranch(walker, recursion + 1, NodeType.THIS_EXPRESSION, Language.Key.THIS); //TokenType.KEYWORD, "this");
			if (thi == null) {
				return null;
			} else {
				return new Branch(NodeType.OUTER_THIS_EXPRESSION, t, dot, thi);
			}
		}
		
		case NodeType.OUTER_SUPER_CONSTRUCTOR_CALL_EXPRESSION: {
			Node outerThis = parseAny(walker, recursion + 1, NodeType.OUTER_THIS_EXPRESSION, NodeType.TYPE);
			
			if (outerThis == null) {
				return null;
			}
			
			Node dot = parseInner(walker, recursion + 1, NodeType.DOT);
			if (dot == null) {
				return null;
			}
			
			Node sup = parseToken(walker, recursion + 1, Language.Key.SUPER); //TokenType.KEYWORD, "super");
			if (sup == null) {
				return null;
			}
			
			Node argsOrDot = parseAny(walker, recursion + 1, NodeType.DOT, NodeType.ARGUMENTS);
			if (argsOrDot == null) {
				return null;
			}
			
			if (argsOrDot.getNodeType() == NodeType.DOT) {
				Node nam = expectAny(walker, recursion + 1, NodeType.NAME);
				Node realargs = expectAny(walker, recursion + 1, NodeType.ARGUMENTS);
				return new Branch(NodeType.OUTER_SUPER_METHOD_CALL_EXPRESSION, outerThis, dot, sup, argsOrDot, nam, realargs);
			}
			
			return new Branch(NodeType.OUTER_THIS_EXPRESSION, outerThis, dot, sup, argsOrDot);
		}
		
		case NodeType.TYPE_EXPRESSION: {
			Node t = parseAny(walker, recursion + 1, NodeType.TYPE, NodeType.RETURN_TYPE); // RETURN_TYPE handles special case NodeType.of void
			if (t == null) {
				return null;
			}
			Node dot = parseInner(walker, recursion + 1, NodeType.DOT);
			if (dot == null) {
				return null;
			}
			Node thi = parseToken(walker, recursion + 1, Language.Key.CLASS);//parseToken(walker, recursion + 1, TokenType.KEYWORD, "class");
			if (thi == null) {
				return null;
			} else {
				return new Branch(NodeType.TYPE_EXPRESSION, t, dot, thi);
			}
		}
		
		/*case NodeType.NAMED_LAMBDA_EXPRESSION: {
			Node t = parseAny(walker, recursion + 1, NodeType.TYPE);
			if (t == null) {
				return null;
			}
			Node dcol = parseAny(walker, recursion + 1, NodeType.DOUBLECOLON);
			if (dcol == null) {
				return null;
			}
			Node name = parseToken(walker, recursion + 1, Language.Key.NEW); //TokenType.KEYWORD, "new");
			if (name == null) {
				name = expectAny(walker, recursion + 1, TokenType.NAME);
			}
			return new Branch(NodeType.NAMED_LAMBDA_EXPRESSION, t, dcol, name);
		}*/
		
		case NodeType.LAMBDA_ARGS: {
			Node open = parseAny(walker, recursion + 1, NodeType.NAME, NodeType.OPEN_ROUND_BRACE);
			if (open == null) {
				return null;
			}
			if (open.getNodeType() == NodeType.NAME) {
				return new Branch(NodeType.LAMBDA_ARGS, open);
			}
			Node inner = parseList(walker, recursion + 1, NodeType.ARGUMENT_DECLARATION_LIST, NodeType.COMMA, false, NodeType.LAZY_ARGUMENT_DECLARATION, NodeType.VARIABLE_ARGUMENT_DECLARATION, NodeType.SIMPLE_ARGUMENT_DECLARATION, NodeType.NAME);
			Node close = parseAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE);
			if (close == null) {
				return null;
			}
			return new Branch(NodeType.LAMBDA_ARGS, open, inner, close);
		}
		
		case NodeType.LAMBDA_EXPRESSION: {
			Node args = parseAny(walker, recursion + 1, NodeType.LAMBDA_ARGS);
			if (args == null) {
				return null;
			}
			Node op = parseToken(walker, recursion + 1, TokenType.OPERATOR, "->");
			if (op == null) {
				return null;
			}
			Node rhs = expectAny(walker, recursion + 1, NodeType.BLOCK_STATEMENT, NodeType.EXPRESSION);
			return new Branch(NodeType.LAMBDA_EXPRESSION, args, op, rhs);
		}
		
		case NodeType.SIMPLE_EXPRESSION: {
			Node lhs = parseAny(walker, recursion + 1,
					NodeType.TYPE_NAMED_LAMBDA_EXPRESSION,
					NodeType.SUPER,
					NodeType.THIS_EXPRESSION,
					NodeType.OUTER_SUPER_CONSTRUCTOR_CALL_EXPRESSION, // A weird edge-case
					NodeType.OUTER_THIS_EXPRESSION,
					NodeType.TYPE_EXPRESSION,
					NodeType.LITERAL_EXPRESSION,
					NodeType.BRACED_EXPRESSION,
					NodeType.GENERIC_REFERENCE_EXPRESSION,
					NodeType.REFERENCE_EXPRESSION,
					NodeType.NEW_EXPRESSION);
			boolean done = false;
			
			while (lhs != null && !done && !walker.isAtEnd() &&
					(walker.peek().is(TokenType.OPERATOR, "[")
							|| walker.peek().is(TokenType.OPERATOR, ".")
							|| walker.peek().is(TokenType.OPERATOR, "::")
							|| walker.peek().is(TokenType.OPERATOR, "("))) {
				if ((lhs.getNodeType() == NodeType.REFERENCE_EXPRESSION || lhs.getNodeType() == NodeType.GENERIC_REFERENCE_EXPRESSION) && walker.peek().is(TokenType.OPERATOR, "(")) {
					lhs = new Branch(NodeType.AUTOMATIC_METHOD_CALL_EXPRESSION,
							lhs,
							parseInner(walker, recursion + 1, NodeType.ARGUMENTS));
				} else if (lhs.getNodeType() == NodeType.SUPER && walker.peek().is(TokenType.OPERATOR, "(")) {
					lhs = new Branch(NodeType.SUPER_CONSTRUCTOR_CALL_EXPRESSION,
							lhs,
							parseInner(walker, recursion + 1, NodeType.ARGUMENTS));
				} else if (lhs.getNodeType() == NodeType.THIS_EXPRESSION && walker.peek().is(TokenType.OPERATOR, "(")) {
					lhs = new Branch(NodeType.THIS_CONSTRUCTOR_CALL_EXPRESSION,
							lhs,
							parseInner(walker, recursion + 1, NodeType.ARGUMENTS));
				} else if (walker.peek().is(TokenType.OPERATOR, "::")) {
					Node dcol = parseInner(walker, recursion + 1, NodeType.DOUBLECOLON);
					Node nam = parseToken(walker, recursion + 1, Language.Key.NEW); //TokenType.KEYWORD, "new");
					if (nam == null) {
						nam = expectAny(walker, recursion + 1, NodeType.NAME);
					}
					lhs = new Branch(NodeType.NAMED_LAMBDA_EXPRESSION,
							lhs,
							dcol,
							nam);
				} else if (walker.peek().is(TokenType.OPERATOR, ".")) {
					boolean isThis = lhs.getNodeType() == NodeType.THIS_EXPRESSION;
					boolean isSuper = lhs.getNodeType() == NodeType.SUPER;
					Node dot = parseInner(walker, recursion + 1, NodeType.DOT);
					Node specialNew = parseAny(walker, recursion + 1, NodeType.NEW_EXPRESSION);
					if (specialNew != null) {
						lhs = new Branch(NodeType.SPECIAL_NEW_EXPRESSION,
								lhs,
								dot,
								specialNew);
					} else {
						Node nam = expectAny(walker, recursion + 1, NodeType.NAME, NodeType.THIS_EXPRESSION, NodeType.GENERIC_REFERENCE_NAME);
						if (walker.peek().is(TokenType.OPERATOR, "(")) {
							lhs = new Branch(isThis ? NodeType.THIS_METHOD_CALL_EXPRESSION : (isSuper ? NodeType.SUPER_METHOD_CALL_EXPRESSION : NodeType.NORMAL_METHOD_CALL_EXPRESSION),
									lhs,
									dot,
									nam,
									parseInner(walker, recursion + 1, NodeType.ARGUMENTS));
						} else {
							lhs = new Branch(/*isThis ? NodeType.THIS_REFERENCE_EXPRESSION : (isSuper ? NodeType.SUPER_REFERENCE_EXPRESSION : */ (NodeType.SUBREFERENCE_EXPRESSION),
									lhs,
									dot,
									nam);
						}
					}
				} else if (lhs.getNodeType() != NodeType.SUPER && lhs.getNodeType() != NodeType.THIS_EXPRESSION && walker.peek().is(TokenType.OPERATOR, "[")) {
					Node open = parseInner(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE);
					/*if (walker.peek().is(TokenType.OPERATOR, "]")) {
						//ScanWalker pos = walker.clone();
						Node close = parseInner(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE);
						lhs = new Branch(NodeType.SPECIAL_ARRAY_TYPE_EXPRESSION, open, close);
					} else {*/
						lhs = new Branch(NodeType.ARRAY_INDEX_EXPRESSION,
								lhs,
								open,
								expectAny(walker, recursion + 1, NodeType.EXPRESSION),
								expectAny(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE));
					//}
				} else {
					done = true;
				}
			}
			
			return lhs;
		}
		
		case NodeType.TYPE_NAMED_LAMBDA_EXPRESSION: {
			Node typ = parseAny(walker, recursion + 1, NodeType.TYPE);
			if (typ == null) {
				return null;
			}
			Node dcol = parseAny(walker, recursion + 1, NodeType.DOUBLECOLON);
			if (dcol == null) {
				return null;
			}
			Node nam = parseToken(walker, recursion + 1, Language.Key.NEW); //TokenType.KEYWORD, "new");
			if (nam == null) {
				nam = expectAny(walker, recursion + 1, NodeType.NAME);
			}
			return new Branch(NodeType.TYPE_NAMED_LAMBDA_EXPRESSION, typ, dcol, nam);
		}
		
		case NodeType.NEW_EXPRESSION: {
			Node keyword = parseToken(walker, recursion + 1, Language.Key.NEW); //TokenType.KEYWORD, "new");
			if (keyword == null) {
				return null;
			} else {
				Node typ = expectAny(walker, recursion + 1, NodeType.TYPE);
				if (typ.getNodeType() == NodeType.TYPE && ((Branch)typ).getSubnode(0).getNodeType() == NodeType.ARRAY_TYPE) {
					return new Branch(NodeType.NEW_INITIALISED_ARRAY_EXPRESSION,
							keyword,
							typ,
							expectAny(walker, recursion + 1, NodeType.ARRAY_INITIALISER));
				}
				if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "[")) {
					Node opener = parseAny(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE);
					/*if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "]")) {
						Node closer = parseAny(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE);
						return new Branch(NodeType.NEW_INITIALISED_ARRAY_EXPRESSION,
								keyword,
								typ,
								opener,
								closer,
								expectAny(walker, recursion + 1, NodeType.ARRAY_INITIALISER));
					} else*/ {
						return new Branch(NodeType.NEW_CLEARED_ARRAY_EXPRESSION,
								keyword,
								typ,
								opener,
								expectAny(walker, recursion + 1, NodeType.EXPRESSION),
								expectAny(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE),
								expectAny(walker, recursion + 1, NodeType.ARRAY_TYPE_TAIL));
					}
				} else {
					Node args = expectAny(walker, recursion + 1, NodeType.ARGUMENTS);
					if (!walker.isAtEnd() && walker.peek().is(TokenType.OPERATOR, "{")) {
						return new Branch(NodeType.NEW_CLASS_EXPRESSION,
								keyword,
								typ,
								args,
								expectAny(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE),
								parseInner(walker, recursion + 1, NodeType.CLASS_MEMBERS),
								expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
					} else {
						return new Branch(NodeType.NEW_OBJECT_EXPRESSION,
								keyword,
								typ,
								args);
					}
					/*
					return new Branch(NodeType.NEW_OBJECT_EXPRESSION,
							keyword,
							typ,
							expectAny(walker, recursion + 1, NodeType.ARGUMENTS));*/
				}
			}
		}
		
		case NodeType.ARRAY_TYPE_TAIL: {
			Node tmp;
			Branch result = new Branch(NodeType.ARRAY_TYPE_TAIL);
			while ((tmp = parseAny(walker, recursion + 1, NodeType.ARRAY_TYPE_PART)) != null) {
				result.append(tmp);
			}
			return result;
		}
		
		case NodeType.ARRAY_TYPE_PART: {
			Node open = parseAny(walker, recursion + 1, NodeType.OPEN_SQUARE_BRACE);
			if (open == null) {
				return null;
			}
			Node close = parseAny(walker, recursion + 1, NodeType.CLOSE_SQUARE_BRACE);
			if (close == null) {
				return null;
			}
			return new Branch(NodeType.ARRAY_TYPE_PART, open, close);
		}
		
		case NodeType.UNARY_EXPRESSION: {
			Node op = parseInner(walker, recursion + 1, NodeType.UNARY_OPERATOR);
			if (op == null) {
				Node open = parseInner(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
				if (open == null) {
					return null;
				} else {
					Node typ = parseInner(walker, recursion + 1, NodeType.ANDABLE_TYPE);
					if (typ == null) {
						return null;
					} else {
						Node close = parseInner(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE);
						if (close == null) {
							return null;
						} else {
							// TODO: Should parsing EXPRESSION here really work?
							Node expr = parseAny(walker, recursion + 1, NodeType.UNARY_EXPRESSION, NodeType.SIMPLE_EXPRESSION);
							if (expr == null) {
								return null;
							} else {
								return new Branch(NodeType.CAST_EXPRESSION, open, typ, close, expr);
							}
						}
					}
				}
			} else {
				Node rhs = parseAny(walker, recursion + 1, NodeType.UNARY_EXPRESSION, NodeType.SIMPLE_EXPRESSION);
				if (rhs.getNodeType() == NodeType.STRING_LITERAL_EXPRESSION) {
					return null; // XXX This is a bit of a hack to prevent (x) + "str" evaluating as a cast
				}
				return new Branch(NodeType.UNARY_EXPRESSION,
						op,
						rhs);
			}
		}
		
		case NodeType.MULTIPLICATIVE_EXPRESSION: {
			Node lhs = parseAny(walker, recursion + 1, NodeType.UNARY_EXPRESSION, NodeType.COUNT_EXPRESSION);
			boolean done = false;
			while (lhs != null && !walker.isAtEnd() && !done) {
				Node op = parseAny(walker, recursion, NodeType.MULTIPLICATIVE_OPERATOR);
				if (op == null) {
					done = true;
				} else {
					lhs = new Branch(NodeType.MULTIPLICATIVE_EXPRESSION,
							lhs,
							op,
							expectAny(walker, recursion + 1, NodeType.UNARY_EXPRESSION, NodeType.SIMPLE_EXPRESSION));
				}
			}
			return lhs;
		}
		
		case NodeType.ADDITIVE_EXPRESSION: {
			Node lhs = parseAny(walker, recursion + 1, NodeType.MULTIPLICATIVE_EXPRESSION);
			boolean done = false;
			while (lhs != null && !walker.isAtEnd() && !done) {
				Node op = parseAny(walker, recursion, NodeType.ADDITIVE_OPERATOR);
				if (op == null) {
					done = true;
				} else {
					lhs = new Branch(NodeType.ADDITIVE_EXPRESSION,
							lhs,
							op,
							expectAny(walker, recursion + 1, NodeType.MULTIPLICATIVE_EXPRESSION));
				}
			}
			return lhs;
		}
		
		case NodeType.SHIFT_EXPRESSION: {
			Node lhs = parseAny(walker, recursion + 1, NodeType.ADDITIVE_EXPRESSION);
			boolean done = false;
			while (lhs != null && !walker.isAtEnd() && !done) {
				Node op = parseAny(walker, recursion, NodeType.SHIFT_OPERATOR);
				if (op == null) {
					done = true;
				} else {
					lhs = new Branch(NodeType.SHIFT_EXPRESSION,
							lhs,
							op,
							expectAny(walker, recursion + 1, NodeType.ADDITIVE_EXPRESSION));
				}
			}
			return lhs;
		}
		
		case NodeType.COMPARISON_EXPRESSION: {
			Node lhs = parseAny(walker, recursion + 1, NodeType.SHIFT_EXPRESSION);
			boolean done = false;
			while (lhs != null && !walker.isAtEnd() && !done) {
				Node op = parseAny(walker, recursion, NodeType.COMPARISON_OPERATOR);
				if (op == null) {
					done = true;
				} else {
					lhs = new Branch(NodeType.COMPARISON_EXPRESSION,
							lhs,
							op,
							expectAny(walker, recursion + 1, NodeType.SHIFT_EXPRESSION));
				}
			}
			return lhs;
		}
		
		case NodeType.INSTANCEOF_EXPRESSION: {
			Node lhs = parseAny(walker, recursion + 1, NodeType.COMPARISON_EXPRESSION);
			boolean done = false;
			while (lhs != null && !walker.isAtEnd() && !done) {
				Node op = parseToken(walker, recursion + 1, Language.Key.INSTANCEOF); //TokenType.KEYWORD, "instanceof");
				if (op == null) {
					done = true;
				} else {
					lhs = new Branch(NodeType.INSTANCEOF_EXPRESSION,
							lhs,
							op,
							expectAny(walker, recursion + 1, NodeType.TYPE));
				}
			}
			return lhs;
		}
		
		case NodeType.EQUALITY_EXPRESSION: {
			Node lhs = parseAny(walker, recursion + 1, NodeType.INSTANCEOF_EXPRESSION);
			boolean done = false;
			while (lhs != null && !walker.isAtEnd() && !done) {
				Node op = parseAny(walker, recursion, NodeType.EQUALITY_OPERATOR);
				if (op == null) {
					done = true;
				} else {
					lhs = new Branch(NodeType.EQUALITY_EXPRESSION,
							lhs,
							op,
							expectAny(walker, recursion + 1, NodeType.INSTANCEOF_EXPRESSION));
				}
			}
			return lhs;
		}
		
		/*case NodeType.LOGICAL_EXPRESSION: {
			Node lhs = parseAny(walker, recursion + 1, NodeType.EQUALITY_EXPRESSION);
			boolean done = false;
			while (lhs != null && !walker.isAtEnd() && !done) {
				Node op = parseAny(walker, recursion, NodeType.LOGICAL_OPERATOR);
				if (op == null) {
					done = true;
				} else {
					lhs = new Branch(NodeType.LOGICAL_EXPRESSION,
							lhs,
							op,
							expectAny(walker, recursion + 1, NodeType.EQUALITY_EXPRESSION));
				}
			}
			return lhs;
		}*/

		case NodeType.BITWISE_AND_EXPRESSION:
			return parseSimpleBinop(walker, recursion,
					NodeType.BITWISE_AND_EXPRESSION,
					NodeType.BITWISE_AND_OPERATOR,
					NodeType.EQUALITY_EXPRESSION);

		case NodeType.BITWISE_XOR_EXPRESSION:
			return parseSimpleBinop(walker, recursion,
					NodeType.BITWISE_XOR_EXPRESSION,
					NodeType.BITWISE_XOR_OPERATOR,
					NodeType.BITWISE_AND_EXPRESSION);

		case NodeType.BITWISE_OR_EXPRESSION:
			return parseSimpleBinop(walker, recursion,
					NodeType.BITWISE_OR_EXPRESSION,
					NodeType.BITWISE_OR_OPERATOR,
					NodeType.BITWISE_XOR_EXPRESSION);

		case NodeType.LOGICAL_AND_EXPRESSION:
			return parseSimpleBinop(walker, recursion,
					NodeType.LOGICAL_AND_EXPRESSION,
					NodeType.LOGICAL_AND_OPERATOR,
					NodeType.BITWISE_OR_EXPRESSION);

		case NodeType.LOGICAL_OR_EXPRESSION:
			return parseSimpleBinop(walker, recursion,
					NodeType.LOGICAL_OR_EXPRESSION,
					NodeType.LOGICAL_OR_OPERATOR,
					NodeType.LOGICAL_AND_EXPRESSION);
		
		
		case NodeType.CONDITIONAL_EXPRESSION: {
			Node cond = parseAny(walker, recursion + 1, NodeType.LOGICAL_OR_EXPRESSION /*NodeType.LOGICAL_EXPRESSION*/); // TODO: Change to only bracketed expression
			if (cond == null) {
				return null;
			}
			Node q = parseToken(walker, recursion + 1, TokenType.OPERATOR, "?");
			if (q == null) {
				return cond;
			}
			Node opt1 = parseAny(walker, recursion + 1, NodeType.LAMBDA_EXPRESSION, NodeType.CONDITIONAL_EXPRESSION, NodeType.LOGICAL_OR_EXPRESSION);
			Node c = parseToken(walker, recursion + 1, TokenType.OPERATOR, ":"); // TODO: Expect
			Node opt2 = parseAny(walker, recursion + 1, NodeType.LAMBDA_EXPRESSION, NodeType.CONDITIONAL_EXPRESSION, NodeType.LOGICAL_OR_EXPRESSION);
			return new Branch(NodeType.CONDITIONAL_EXPRESSION, cond, q, opt1, c, opt2);
		}
		
		case NodeType.ASSIGNMENT_EXPRESSION: {
			Node lhs = parseInner(walker, recursion + 1, NodeType.SIMPLE_EXPRESSION);
			
			if (lhs != null && !walker.isAtEnd() && (lhs.getNodeType() == NodeType.REFERENCE_EXPRESSION || lhs.getNodeType() == NodeType.SUBREFERENCE_EXPRESSION || lhs.getNodeType() == NodeType.ARRAY_INDEX_EXPRESSION)) {
				Node op = parseInner(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR);
				if (op == null) {
					//op = parseInner(walker, recursion + 1, NodeType.COUNT_OPERATOR);
					//if (op == null) {
						return null;
					//} else {
						//return new Branch(NodeType.COUNT_EXPRESSION, lhs, op);
					//}
				} else {
					return new Branch(NodeType.ASSIGNMENT_EXPRESSION,
							lhs,
							op,
							expectAny(walker, recursion + 1, NodeType.EXPRESSION));
				}
			} else {
				return null;
			}
		}
		
		case NodeType.COUNT_EXPRESSION: {
			Node lhs = parseInner(walker, recursion + 1, NodeType.SIMPLE_EXPRESSION);
			
			if (lhs != null && !walker.isAtEnd()/* && (lhs.getNodeType() == NodeType.REFERENCE_EXPRESSION || lhs.getNodeType() == NodeType.SUBREFERENCE_EXPRESSION || lhs.getNodeType() == NodeType.ARRAY_INDEX_EXPRESSION)*/) {
				Node op = parseInner(walker, recursion + 1, NodeType.COUNT_OPERATOR);
				if (op == null) {
					return lhs;
				} else {
					return new Branch(NodeType.COUNT_EXPRESSION, lhs, op);
				}
			} else {
				return lhs;
			}
		}
		
		case NodeType.ASSIGNMENT_OPERATOR: {
			Node result = null;

			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "+=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "-=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "*=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "/=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "%=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "&=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "|=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "^=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, "<<=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, ">>>=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ASSIGNMENT_OPERATOR, TokenType.OPERATOR, ">>=");
			
			return result;
		}
		
		case NodeType.COUNT_OPERATOR: {
			Node result = null;

			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COUNT_OPERATOR, TokenType.OPERATOR, "--");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COUNT_OPERATOR, TokenType.OPERATOR, "++");
			
			return result;
		}
		
		case NodeType.UNARY_OPERATOR: {
			Node result = parseInner(walker, recursion + 1, NodeType.COUNT_OPERATOR);

			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.UNARY_OPERATOR, TokenType.OPERATOR, "-");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.UNARY_OPERATOR, TokenType.OPERATOR, "+");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.UNARY_OPERATOR, TokenType.OPERATOR, "!");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.UNARY_OPERATOR, TokenType.OPERATOR, "~");
			
			return result;
		}
		
		case NodeType.MULTIPLICATIVE_OPERATOR: {
			Node result = null;

			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "*");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "/");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "%");
			//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "&");
			//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "|");
			//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.MULTIPLICATIVE_OPERATOR, TokenType.OPERATOR, "^");
			
			return result;
		}
		
		case NodeType.ADDITIVE_OPERATOR: {
			Node result = null;

			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ADDITIVE_OPERATOR, TokenType.OPERATOR, "+");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ADDITIVE_OPERATOR, TokenType.OPERATOR, "-");
			//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ADDITIVE_OPERATOR, TokenType.OPERATOR, "&");
			//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.ADDITIVE_OPERATOR, TokenType.OPERATOR, "|");
			
			return result;
		}

		case NodeType.SHIFT_OPERATOR: {
			Node result = null;

			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.SHIFT_OPERATOR, TokenType.OPERATOR, "<<");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.SHIFT_OPERATOR, TokenType.OPERATOR, ">>");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.SHIFT_OPERATOR, TokenType.OPERATOR, ">>>");
			// Special handling of combined ">" characters is required for generics
			result = result != null ? result : parseSpecialTokenBranch(walker, recursion + 1, NodeType.SHIFT_OPERATOR, TokenType.OPERATOR, ">", 3);
			result = result != null ? result : parseSpecialTokenBranch(walker, recursion + 1, NodeType.SHIFT_OPERATOR, TokenType.OPERATOR, ">", 2);
			
			return result;
		}
		
		case NodeType.COMPARISON_OPERATOR: {
			Node result = null;
			
			// Specifically fail if we can parse (especially muliple ">" characters) as a shift operator instead
			Node shiftop = parseAny(walker, recursion + 1, NodeType.SHIFT_OPERATOR);
			if (shiftop != null) {
				return null;
			}

			//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, "==");
			//result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, "!=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, "<");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, "<=");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, ">");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.COMPARISON_OPERATOR, TokenType.OPERATOR, ">=");
			
			return result;
		}
		
		case NodeType.EQUALITY_OPERATOR: {
			Node result = null;

			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.EQUALITY_OPERATOR, TokenType.OPERATOR, "==");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.EQUALITY_OPERATOR, TokenType.OPERATOR, "!=");
			
			return result;
		}
		
		case NodeType.BITWISE_AND_OPERATOR:
			return parseTokenBranch(walker, recursion + 1,
					NodeType.BITWISE_AND_OPERATOR, "&");
			
		case NodeType.BITWISE_XOR_OPERATOR:
			return parseTokenBranch(walker, recursion + 1,
					NodeType.BITWISE_XOR_OPERATOR, "^");
			
		case NodeType.BITWISE_OR_OPERATOR:
			return parseTokenBranch(walker, recursion + 1,
					NodeType.BITWISE_AND_OPERATOR, "|");
		
		case NodeType.LOGICAL_AND_OPERATOR:
			return parseTokenBranch(walker, recursion + 1,
					NodeType.LOGICAL_AND_OPERATOR, "&&");
			
		case NodeType.LOGICAL_OR_OPERATOR:
			return parseTokenBranch(walker, recursion + 1,
					NodeType.LOGICAL_OR_OPERATOR, "||");
		
		case NodeType.LOGICAL_OPERATOR: {
			Node result = null;

			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.LOGICAL_OPERATOR, TokenType.OPERATOR, "&&");
			result = result != null ? result : parseTokenBranch(walker, recursion + 1, NodeType.LOGICAL_OPERATOR, TokenType.OPERATOR, "||");
			
			return result;
		}
		
		case NodeType.EXPRESSION:
			return parseAny(walker, recursion + 1,
					NodeType.LAMBDA_EXPRESSION,
					NodeType.ASSIGNMENT_EXPRESSION,
					NodeType.CONDITIONAL_EXPRESSION,
					NodeType.LOGICAL_OR_EXPRESSION);
			
		case NodeType.EXPRESSIONS:
			return parseList(walker, recursion + 1, NodeType.EXPRESSIONS, NodeType.COMMA, false, NodeType.EXPRESSION);

		case NodeType.ARRAY_EXPRESSIONS:
			return parseList(walker, recursion + 1, NodeType.ARRAY_EXPRESSIONS, NodeType.COMMA, true, NodeType.ARRAY_INITIALISER, NodeType.EXPRESSION);
			
		case NodeType.MODIFIER_EXPRESSIONS:
			return parseList(walker, recursion + 1, NodeType.MODIFIER_EXPRESSIONS, NodeType.COMMA, true, NodeType.ARRAY_INITIALISER, NodeType.SIMPLE_ASSIGN, NodeType.EXPRESSION);
		
		case NodeType.SIMPLE_ASSIGN: {
			Node nam = parseAny(walker, recursion + 1, NodeType.NAME);
			if (nam == null) {
				return null;
			}
			Node eq = parseToken(walker, recursion + 1, TokenType.OPERATOR, "=");
			if (eq == null) {
				return null;
			}
			return new Branch(NodeType.SIMPLE_ASSIGN,
					nam,
					eq,
					expectAny(walker, recursion + 1, NodeType.ARRAY_INITIALISER, NodeType.EXPRESSION));
		}
			
		case NodeType.SIMPLE_GENERIC_WILDCARD:
			return parseTokenBranch(walker, recursion + 1, NodeType.SIMPLE_GENERIC_WILDCARD, TokenType.OPERATOR, "?");

		case NodeType.EXTENDED_GENERIC_WILDCARD: {
			Node start = parseTokenBranch(walker, recursion + 1, NodeType.QUESTIONMARK, TokenType.OPERATOR, "?");
			if (start == null) {
				return null;
			}
			Node ext = parseToken(walker, recursion + 1, Language.Key.EXTENDS); //TokenType.KEYWORD, "extends");
			if (ext == null) {
				return null;
			}
			Node typ = expectAny(walker, recursion + 1, NodeType.ANDABLE_TYPE);
			return new Branch(NodeType.EXTENDED_GENERIC_WILDCARD, start, ext, typ);
		}
		
		case NodeType.ANDABLE_TYPE: {
			ScanWalker pos = walker.clone();
			Node firstType = parseAny(walker, recursion + 1, NodeType.TYPE);
			if (firstType == null) {
				return null;
			}
			walker.reset(pos);
            ScanWalker.recycle(pos);
			return parseList(walker, recursion + 1, NodeType.ANDABLE_TYPE, NodeType.SINGLE_AND, false, NodeType.TYPE);
		}
		
		case NodeType.SINGLE_AND: {
			return parseTokenBranch(walker, recursion + 1, NodeType.SINGLE_AND, TokenType.OPERATOR, "&");
		}
		
		case NodeType.SUPER_GENERIC_WILDCARD: {
			Node start = parseTokenBranch(walker, recursion + 1, NodeType.QUESTIONMARK, TokenType.OPERATOR, "?");
			if (start == null) {
				return null;
			}
			Node sup = parseToken(walker, recursion + 1, Language.Key.SUPER); //TokenType.KEYWORD, "super");
			if (sup == null) {
				return null;
			}
			Node typ = expectAny(walker, recursion + 1, NodeType.TYPE);
			return new Branch(NodeType.SUPER_GENERIC_WILDCARD, start, sup, typ);
		}
			
		case NodeType.GENERIC_VALUE:
			//return new Branch(NodeType.GENERIC_VALUE,
			return parseAny(walker, recursion + 1,
						NodeType.TYPE,
						NodeType.EXTENDED_GENERIC_WILDCARD,
						NodeType.SUPER_GENERIC_WILDCARD,
						NodeType.SIMPLE_GENERIC_WILDCARD);//);
		
		case NodeType.GENERIC_EXPRESSIONS:
			return parseList(walker, recursion + 1, NodeType.GENERIC_EXPRESSIONS, NodeType.COMMA, false, NodeType.GENERIC_VALUE);
		
		case NodeType.BRACED_EXPRESSION: {
			Node start = parseInner(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
			if (start == null) {
				return null;
			} else {
				return new Branch(NodeType.BRACED_EXPRESSION,
						start,
						expectAny(walker, recursion + 1, NodeType.EXPRESSION),
						expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE));
			}
		}
			
		case NodeType.ARGUMENTS: {
			Node start = parseInner(walker, recursion + 1, NodeType.OPEN_ROUND_BRACE);
			if (start == null) {
				return null;
			} else {
				return new Branch(NodeType.ARGUMENTS,
						start,
						parseInner(walker, recursion + 1, NodeType.EXPRESSIONS),
						expectAny(walker, recursion + 1, NodeType.CLOSE_ROUND_BRACE));
			}
		}
		
		case NodeType.ARRAY_INITIALISER: {
			Node start = parseInner(walker, recursion + 1, NodeType.OPEN_CURLY_BRACE);
			if (start == null) {
				return null;
			} else {
				return new Branch(NodeType.ARRAY_INITIALISER,
						start,
						parseInner(walker, recursion + 1, NodeType.ARRAY_EXPRESSIONS),
						expectAny(walker, recursion + 1, NodeType.CLOSE_CURLY_BRACE));
			}
		}
		
		case NodeType.GENERIC_ARGUMENTS: {
			Node start = parseInner(walker, recursion + 1, NodeType.OPEN_ANGLE_BRACE);
			if (start == null) {
				return null;
			} else {
				Node middle = parseAny(walker, recursion + 1, NodeType.GENERIC_EXPRESSIONS);
				if (middle == null) {
					return null;
				}
				Node end = parseAny(walker, recursion + 1, NodeType.CLOSE_ANGLE_BRACE);
				if (end == null) {
					return null;
				}
				return new Branch(NodeType.GENERIC_ARGUMENTS,
						start,
						middle,
						end);
			}
		}
		
		case NodeType.SLOTS:
			return parseList(walker, recursion + 1, NodeType.SLOTS, NodeType.COMMA, false, NodeType.INITIALISED_SLOT);
		
		case NodeType.INITIALISED_SLOT: {
			Node n = parseInner(walker, recursion + 1, NodeType.INDEXED_NAME);
			if (n == null) {
				return null;
			} else {
				Token eq = parseToken(walker, recursion + 1, TokenType.OPERATOR, "=");
				if (eq == null) {
					return new Branch(NodeType.UNINITIALISED_SLOT, n);
				} else {
					return new Branch(NodeType.INITIALISED_SLOT, n, eq, expectAny(walker, recursion + 1, NodeType.EXPRESSION, NodeType.ARRAY_INITIALISER));
				}
			}
		}
		
		case NodeType.SIMPLE_ARGUMENT_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
			if (t == null) {
				return null;
			} else {
				Node n = parseInner(walker, recursion + 1, NodeType.INDEXED_NAME);
				if (n == null) {
					return null;
				} else {
					return new Branch(NodeType.SIMPLE_ARGUMENT_DECLARATION, mods, t, n);
				}
			}
		}
		
		case NodeType.LAZY_ARGUMENT_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node t = parseInner(walker, recursion + 1, NodeType.LAZY_TYPE);
			if (t == null) {
				return null;
			} else {
				Node n = parseInner(walker, recursion + 1, NodeType.INDEXED_NAME);
				if (n == null) {
					return null;
				} else {
					return new Branch(NodeType.SIMPLE_ARGUMENT_DECLARATION, mods, t, n);
				}
			}
		}
		
		case NodeType.LAZY_TYPE: {
			Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
			if (t == null) {
				return null;
			}
			Node bar = null;
			Branch result = null;
			while ((bar = parseToken(walker, recursion + 1, TokenType.OPERATOR, "|")) != null) {
				Node nextt = parseInner(walker, recursion + 1, NodeType.TYPE);
				if (nextt == null) {
					return null;
				}
				if (result == null) {
					result = new Branch(NodeType.LAZY_TYPE);
					result.append(t);
				}
				result.append(bar);
				result.append(nextt);
			}
			return result; // Will be null unless one or more "|" followed by another type was found
		}
		
		case NodeType.VARIABLE_ARGUMENT_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
			if (t == null) {
				return null;
			} else {
				Node dots = parseToken(walker, recursion + 1, TokenType.OPERATOR, "...");
				if (dots == null) {
					return null;
				} else {
					Node n = parseInner(walker, recursion + 1, NodeType.INDEXED_NAME);
					if (n == null) {
						return null;
					} else {
						return new Branch(NodeType.VARIABLE_ARGUMENT_DECLARATION, mods, t, dots, n);
					}
				}
			}
		}
		
		case NodeType.SIMPLE_GENERIC_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node n = parseInner(walker, recursion + 1, NodeType.NAME);
			if (n == null) {
				return null;
			} else {
				return new Branch(NodeType.SIMPLE_GENERIC_DECLARATION, mods, n);
			}
		}
		
		case NodeType.SIMPLE_EXTENDED_GENERIC_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node n = parseInner(walker, recursion + 1, NodeType.NAME);
			if (n == null) {
				return null;
			}
			Node ext = parseToken(walker, recursion + 1, Language.Key.EXTENDS); //TokenType.KEYWORD, "extends");
			if (ext == null) {
				return null;
			}
			Node typ = expectAny(walker, recursion + 1, NodeType.ANDABLE_TYPE);
			return new Branch(NodeType.SIMPLE_EXTENDED_GENERIC_DECLARATION, mods, n, ext, typ);
		}
		
		case NodeType.SIMPLE_TYPED_GENERIC_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
			if (t == null) {
				return null;
			} else {
				Node n = parseInner(walker, recursion + 1, NodeType.NAME);
				if (n == null) {
					return null;
				} else {
					return new Branch(NodeType.SIMPLE_TYPED_GENERIC_DECLARATION, mods, t, n);
				}
			}
		}
		
		case NodeType.VARIABLE_GENERIC_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node dots = parseToken(walker, recursion + 1, TokenType.OPERATOR, "...");
			if (dots == null) {
				return null;
			} else {
				Node n = parseInner(walker, recursion + 1, NodeType.NAME);
				if (n == null) {
					return null;
				} else {
					return new Branch(NodeType.VARIABLE_GENERIC_DECLARATION, mods, dots, n);
				}
			}
		}
		
		case NodeType.VARIABLE_TYPED_GENERIC_DECLARATION: {
			Node mods = parseInner(walker, recursion + 1, NodeType.MODIFIER_LIST);
			Node t = parseInner(walker, recursion + 1, NodeType.TYPE);
			if (t == null) {
				return null;
			} else {
				Node dots = parseToken(walker, recursion + 1, TokenType.OPERATOR, "...");
				if (dots == null) {
					return null;
				} else {
					Node n = parseInner(walker, recursion + 1, NodeType.NAME);
					if (n == null) {
						return null;
					} else {
						return new Branch(NodeType.VARIABLE_TYPED_GENERIC_DECLARATION, mods, t, dots, n);
					}
				}
			}
		}
		
		case NodeType.UNIT:
			return new Branch(NodeType.UNIT,
					parseInner(walker, recursion + 1, NodeType.PACKAGE_DECLARATION),
					parseList(walker, recursion + 1, NodeType.IMPORT_DECLARATIONS, null, false,
							NodeType.IMPORT_DECLARATION),
					parseInner(walker, recursion + 1, NodeType.TYPE_DECLARATIONS),
					expectAny(walker, recursion + 1, NodeType.EOF));
		
		default:
			//System.out.println("TODO: Parsing of " + type);
			//return new Branch(NodeType.ERROR_ONLY).annotate(ErrorType.INTERNAL_ERROR, "TODO: Parsing of " + type);
			return null;
		}
	}

	public Node parseSafely(ScanWalker walker, int recursion, NodeType type) {
		checkRecursion(walker, recursion);
		ScanWalker w = walker.clone();
		Node r = parseInner(walker, recursion + 1, type);
		if (r != null) {
			walker.reset(w);
		}
        ScanWalker.recycle(w);
		return r;
	}
	
	public Node parseUnit(Scan scan) {
		ScanWalker w = new ScanWalker(scan);
		return parseSafely(w, 0, NodeType.UNIT);
	}
	
	public void checkRecursion(ScanWalker walker, int recursion) {
		if (recursion >= maxRecursion) {
			throw new Error("Recursion got too deep around " + walker.peek());
		}
	}
}