/*-------------------------------------------------------------------------+
|                                                                          |
| Copyright 2005-2011 the ConQAT Project                                   |
|                                                                          |
| Licensed under the Apache License, Version 2.0 (the "License");          |
| you may not use this file except in compliance with the License.         |
| You may obtain a copy of the License at                                  |
|                                                                          |
|    http://www.apache.org/licenses/LICENSE-2.0                            |
|                                                                          |
| Unless required by applicable law or agreed to in writing, software      |
| distributed under the License is distributed on an "AS IS" BASIS,        |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and      |
| limitations under the License.                                           |
+-------------------------------------------------------------------------*/
package eu.cqse.check.framework.shallowparser.languages.visualbasic;

import static eu.cqse.check.framework.scanner.ETokenType.*;
import static eu.cqse.check.framework.shallowparser.languages.visualbasic.EVisualBasicParserState.IN_ENUM;
import static eu.cqse.check.framework.shallowparser.languages.visualbasic.EVisualBasicParserState.IN_EVENT_DECLARATION;
import static eu.cqse.check.framework.shallowparser.languages.visualbasic.EVisualBasicParserState.IN_INTERFACE;
import static eu.cqse.check.framework.shallowparser.languages.visualbasic.EVisualBasicParserState.IN_METHOD;
import static eu.cqse.check.framework.shallowparser.languages.visualbasic.EVisualBasicParserState.IN_SINGLE_LINE_IF;
import static eu.cqse.check.framework.shallowparser.languages.visualbasic.EVisualBasicParserState.IN_TYPE;
import static eu.cqse.check.framework.shallowparser.languages.visualbasic.EVisualBasicParserState.TOP_LEVEL;

import java.util.Arrays;
import java.util.EnumSet;
import java.util.List;

import eu.cqse.check.framework.scanner.ETokenType;
import eu.cqse.check.framework.shallowparser.SubTypeNames;
import eu.cqse.check.framework.shallowparser.framework.EShallowEntityType;
import eu.cqse.check.framework.shallowparser.framework.PropertyAccessNameResolver;
import eu.cqse.check.framework.shallowparser.framework.RecognizerBase;
import eu.cqse.check.framework.shallowparser.framework.ShallowParserBase;

/**
 * VisualBasic.NET shallow parser.
 * 
 * The shallow parser follows the
 * <a href="https://msdn.microsoft.com/en-us/library/aa711636(v=vs.71).aspx">VB.
 * NET</a> specification at
 * 
 * 
 * Notes:
 * <ul>
 * <li>At the current state the parser should support multiple visual basic
 * dialects. There is only one exception: The parser can not deal with single
 * line if statements in other dialects. Expect incomplete entities in those
 * cases.</li>
 * <li>Some unreserved keywords are treated like reserved keywords, as they are
 * only valid in a certain context (e.g. Linq expressions) and we currently do
 * not have such functionality (
 * <a href="https://msdn.microsoft.com/en-us/library/dd409611.aspx">VB.NET
 * Keywords</a>).</li>
 * <li>Getter and Setter of properties are reported as e.g. "getter for <name of
 * property>".</li>
 * <li>Attribute lists that give additional compiler information to all kinds of
 * types, methods etc. are reported as meta annotations.</li>
 * <li>Preprocessor directives are reported as meta entity.</li>
 * <li>Do-Until loops are reported as do-while loops. Note that do loops in
 * VB.NET may behave like while loops, depending on the position of the
 * condition.</li>
 * <li>The Declare structure is reported as method.</li>
 * <li>The form meta data is not parsed into.</li>
 * <li>Lambdas are not distinguished from other variables.</li>
 * </ul>
 */
public class VisualBasicShallowParser extends ShallowParserBase<EVisualBasicParserState> {

        /**
         * All token types that open a new scope.
         */
        private static final List<ETokenType> OPENING_TYPES = Arrays.asList(LPAREN, LBRACE, LBRACK);

        /**
         * All token types that close a scope.
         */
        private static final List<ETokenType> CLOSING_TYPES = Arrays.asList(RPAREN, RBRACE, RBRACK);

        /**
         * All types that do not indicate a new line. This excludes COLON as it allows
         * to continue with a new statement in the very same line.
         */
        private static final EnumSet<ETokenType> NO_NEW_LINE = EnumSet.complementOf(EnumSet.of(EOL, COLON));

        /**
         * All token types that may modify type, attribute or method declarations. Does
         * not include 'MUSTOVERRIDE' as this is an indicator for a different rule.
         */
        private static final EnumSet<ETokenType> DECLARATION_MODIFIER = EnumSet.of(PRIVATE, PUBLIC, PROTECTED, MUSTINHERIT,
                        NOTINHERITABLE, OVERLOADS, SHARED, OVERRIDES, SHADOWS, NOTOVERRIDABLE, FRIEND, READONLY, ASYNC, WITHEVENTS,
                        PARTIAL, WIDENING, NARROWING, CONST, STATIC, DEFAULT, DIM);

        /**
         * All token types a statement can start with.
         */
        private static final EnumSet<ETokenType> STATEMENT_START = EnumSet.of(IDENTIFIER, DIM, RETURN, ME, MYBASE, THROW,
                        AWAIT, RAISEEVENT, REDIM, ADDHANDLER, REMOVEHANDLER, EXIT_DO, EXIT_FOR, EXIT_SUB, EXIT_WHILE, RESUME,
                        ONERROR, STOP, GOTO, YIELD, ERROR, CALL, CONTINUE, END, ERASE, CTYPE);

        /**
         * Types that continue a statement only if EOL is a preceding token or EOL is a
         * following token. https://msdn.microsoft.com/en-us/library/865x40k4.aspx
         */
        private static final EnumSet<ETokenType> STATEMENT_CONTINUATION_BOTH_ONLY = EnumSet.of(COMMA, EQ, ANDEQ, PLUSEQ,
                        MINUSEQ, MULTEQ, DIVEQ, INTDIVEQ, POWEREQ, LSHIFTEQ, RSHIFTEQ, PLUS, MINUS, DIV, INTDIV, MULT, MOD, NOT, GT,
                        LTEQ, GTEQ, POWER, LSHIFT, RSHIFT, ANDALSO, OR, ORELSE, LIKE, XOR, IS, IS_NOT, AGGREGATE, GROUPBY,
                        GROUPJOIN, JOIN, LET, ORDERBY, SELECT, SKIP, SKIPWHILE, TAKE, TAKEWHILE, WHERE, IN, INTO, ON, ASCENDING,
                        DESCENDING, FROM, EQUALS);

        /** Types that continue a statement only if EOL is a preceding token. */
        private static final EnumSet<ETokenType> STATEMENT_CONTINUATION_PRECEDING_ONLY = EnumSet.of(DISTINCT);

        /** Types that continue a statement only if EOL is a following token. */
        private static final EnumSet<ETokenType> STATEMENT_CONTINUATION_FOLLOWING_ONLY = EnumSet.of(DOT, LT);

        /**
         * Types that interrupt a statement. This is typically EOL. Furthermore it
         * contains COLON which directly ends the statement and allows the next
         * statement to start in the same line. Because of single line if statements we
         * have to add ELSE here.
         */
        private static final EnumSet<ETokenType> STATEMENT_INTERRUPT_TYPES = EnumSet.of(EOL, COLON, ELSE, END_IF, END_WHILE,
                        END_SUB, END_FUNCTION, END_NAMESPACE, END_USING, END_WITH, END_TRY, END_EVENT, END_SYNCLOCK, END_SELECT,
                        END_ENUM, END_CLASS, END_TYPE, END_GET, END_SET, END_OPERATOR, END_INTERFACE, END_STRUCTURE);

        /**
         * Types that continue a statement if EOL is a preceding token or EOL is a
         * following token. https://msdn.microsoft.com/en-us/library/865x40k4.aspx
         */
        private static final EnumSet<ETokenType> STATEMENT_CONTINUATION_BOTH = EnumSet
                        .copyOf(STATEMENT_CONTINUATION_BOTH_ONLY);

        /** Types that continue a statement if EOL is a preceding token. */
        private static final EnumSet<ETokenType> STATEMENT_CONTINUATION_PRECEDING = EnumSet
                        .copyOf(STATEMENT_CONTINUATION_PRECEDING_ONLY);

        /** Types that continue a statement if EOL is a following token. */
        private static final EnumSet<ETokenType> STATEMENT_CONTINUATION_FOLLOWING = EnumSet
                        .copyOf(STATEMENT_CONTINUATION_FOLLOWING_ONLY);
        /**
         * Types that indicate a situation where implicit line conversion might be
         * applicable or should not be applied.
         */
        private static final EnumSet<ETokenType> STATEMENT_CONTINUATION_CANDIDATES = EnumSet
                        .copyOf(STATEMENT_INTERRUPT_TYPES);

        static {
                STATEMENT_CONTINUATION_CANDIDATES.addAll(STATEMENT_CONTINUATION_FOLLOWING_ONLY);
                STATEMENT_CONTINUATION_CANDIDATES.addAll(STATEMENT_CONTINUATION_PRECEDING_ONLY);
                STATEMENT_CONTINUATION_CANDIDATES.addAll(STATEMENT_CONTINUATION_BOTH_ONLY);

                STATEMENT_CONTINUATION_PRECEDING.addAll(STATEMENT_CONTINUATION_BOTH_ONLY);
                STATEMENT_CONTINUATION_FOLLOWING.addAll(STATEMENT_CONTINUATION_BOTH_ONLY);

                STATEMENT_CONTINUATION_BOTH.addAll(STATEMENT_CONTINUATION_FOLLOWING_ONLY);
                STATEMENT_CONTINUATION_BOTH.addAll(STATEMENT_CONTINUATION_PRECEDING_ONLY);
        }

        /** Constructor */
        public VisualBasicShallowParser() {
                super(EVisualBasicParserState.class, TOP_LEVEL);

                createMetaRules();
                createNamespaceRule();
                createTypeLikeRules();
                createMethodRules();
                createEventRules();
                createPropertyRules();
                createAttributeRules();
                createEnumRules();
                createSelectCaseRules();
                createConditionalsRules();
                createLoopRules();
                createTryCatchFinallyRules();
                createComplexStatementRules();
                createSimpleStatementRule();
                hideLineSeparators();
        }

        /**
         * Hide line separators EOL and COLON by parsing them without creating nodes.
         */
        private void hideLineSeparators() {

                // Does not include IN_SINGLE_LINE_IF, because we require EOL and COLON
                // as indicators.
                inState(TOP_LEVEL, IN_TYPE, IN_ENUM, IN_EVENT_DECLARATION, IN_INTERFACE, IN_METHOD)
                                .sequence(EnumSet.of(EOL, COLON));

        }

        /**
         * Create rules to match event declarations.
         */
        private void createEventRules() {
                skipToEndOfStatement(inState(IN_TYPE).repeated(DECLARATION_MODIFIER).sequence(EVENT).markStart()
                                .createNode(EShallowEntityType.ATTRIBUTE, "event", 0)).endNode();

                RecognizerBase<EVisualBasicParserState> base = skipToEndOfStatement(
                                inState(IN_TYPE).repeated(DECLARATION_MODIFIER).sequence(IDENTIFIER, EVENT).markStart()
                                                .createNode(EShallowEntityType.ATTRIBUTE, "event", 0));
                base.parseUntil(IN_EVENT_DECLARATION).sequence(END_EVENT).endNode();

                // Parse the handler definitions inside of the custom event
                EVisualBasicParserState[] states = { IN_EVENT_DECLARATION };
                createComplexStatementRule(states, ADDHANDLER, END, ADDHANDLER);
                createComplexStatementRule(states, REMOVEHANDLER, END, REMOVEHANDLER);
                createComplexStatementRule(states, RAISEEVENT, END, RAISEEVENT);
        }

        /**
         * Create rules to match visual basics equivalent to switch/case: select/case.
         */
        private void createSelectCaseRules() {
                skipToEndOfStatement(inState(IN_METHOD, IN_SINGLE_LINE_IF).sequence(SELECTCASE)
                                .createNode(EShallowEntityType.STATEMENT, SubTypeNames.SELECT)).parseUntil(IN_METHOD)
                                                .sequence(ETokenType.END_SELECT).endNode();

                skipToEndOfStatement(inState(IN_METHOD, IN_SINGLE_LINE_IF).sequence(CASE).createNode(EShallowEntityType.META,
                                SubTypeNames.CASE)).optional(ELSE).endNode();
        }

        /**
         * Create rules that match all kinds of loops or the goto statement.
         */
        private void createLoopRules() {
                // DO-WHILE
                RecognizerBase<EVisualBasicParserState> baseRecognizerDoWhile = inState(IN_METHOD, IN_SINGLE_LINE_IF)
                                .sequence(DO).optional(EnumSet.of(WHILE, UNTIL));
                baseRecognizerDoWhile = skipToEndOfStatement(
                                baseRecognizerDoWhile.createNode(EShallowEntityType.STATEMENT, SubTypeNames.DO)).parseUntil(IN_METHOD)
                                                .sequence(LOOP);
                skipToEndOfStatement(baseRecognizerDoWhile).endNode();

                // WHILE
                skipToEndOfStatement(inState(IN_METHOD, IN_SINGLE_LINE_IF).sequence(WHILE)
                                .createNode(EShallowEntityType.STATEMENT, SubTypeNames.WHILE)).parseUntil(IN_METHOD)
                                                .sequence(EnumSet.of(END_WHILE, WEND)).endNode();

                // FOR
                RecognizerBase<EVisualBasicParserState> baseRecognizerFor = skipToEndOfStatement(
                                inState(IN_METHOD, IN_SINGLE_LINE_IF).sequence(FOR).createNode(EShallowEntityType.STATEMENT,
                                                SubTypeNames.FOR)).parseUntil(IN_METHOD).sequence(NEXT);
                skipToEndOfStatement(baseRecognizerFor).endNode();

        }

        /**
         * Create a rule for complex blocks that contain nodes that have to end with
         * continuation. These are e.g. try/catch/finally or if/elseif/else constructs.
         */
        private void createBlockRuleWithContinuation(EnumSet<ETokenType> possibleStartTypes,
                        EnumSet<ETokenType> continuationIndicators, ETokenType terminationType) {

                RecognizerBase<EVisualBasicParserState> base = inState(IN_METHOD, IN_SINGLE_LINE_IF)
                                .sequence(possibleStartTypes).createNode(EShallowEntityType.STATEMENT, -1);
                base = skipToEndOfStatement(base).parseUntil(IN_METHOD);

                base.sequenceBefore(continuationIndicators).endNodeWithContinuation();
                base.sequence(terminationType).endNode();
        }

        /**
         * Create rules that match try catch finally constructs.
         */
        private void createTryCatchFinallyRules() {
                createBlockRuleWithContinuation(EnumSet.of(TRY, CATCH, FINALLY), EnumSet.of(CATCH, FINALLY), END_TRY);
        }

        /**
         * Create rules for more complex statements like WITH, USING and SYNCLOCK.
         */
        private void createComplexStatementRules() {
                EVisualBasicParserState[] states = { IN_METHOD, IN_SINGLE_LINE_IF };
                createComplexStatementRule(states, USING, END_USING);
                createComplexStatementRule(states, WITH, END_WITH);
                createComplexStatementRule(states, SYNCLOCK, END_SYNCLOCK);
        }

        /**
         * Create a rule for complex statements such as WITH and USING.
         */
        private void createComplexStatementRule(EVisualBasicParserState[] states, ETokenType startTokenType,
                        Object... endTokenType) {
                RecognizerBase<EVisualBasicParserState> base = inState(states).sequence(startTokenType)
                                .createNode(EShallowEntityType.STATEMENT, 0, 1);
                skipToEndOfStatement(base).parseUntil(IN_METHOD).sequence(endTokenType).endNode();
        }

        /**
         * Create the rules for enum declaration and definition.
         */
        private void createEnumRules() {
                // Enum declaration
                RecognizerBase<EVisualBasicParserState> base = inState(TOP_LEVEL, IN_TYPE).repeated(DECLARATION_MODIFIER)
                                .sequence(ENUM).createNode(EShallowEntityType.TYPE, SubTypeNames.ENUM, 1);
                skipToEndOfStatement(base).parseUntil(IN_ENUM).sequence(END_ENUM).endNode();

                // Enum definition
                RecognizerBase<EVisualBasicParserState> enumLiteralBase = inState(IN_ENUM).sequence(IDENTIFIER)
                                .createNode(EShallowEntityType.ATTRIBUTE, SubTypeNames.ENUM_LITERAL, 0);
                skipToEndOfStatement(enumLiteralBase).endNode();
        }

        /**
         * Create rules that match properties. A matched property is reported as the
         * shallow entity 'ATTRIBUTE' with potential getter and setter methods.
         */
        private void createPropertyRules() {
                RecognizerBase<EVisualBasicParserState> base = inState(IN_TYPE).repeated(DECLARATION_MODIFIER)
                                .sequence(PROPERTY, IDENTIFIER).createNode(EShallowEntityType.ATTRIBUTE, SubTypeNames.PROPERTY, -1);

                base = skipToEndOfStatement(base);

                // The property is treated as a type if a getter or setter is found
                // next.
                base.sequence(EOL).sequenceBefore(EnumSet.of(GET, SET)).parseUntil(IN_TYPE).sequence(END_PROPERTY).endNode();

                // Otherwise the property could have an automatically created getter and
                // setter and therefore will end without a body.
                base.optional(END_PROPERTY).endNode();
        }

        /**
         * Create rules that cover conditionals (If, ElseIf).
         */
        private void createConditionalsRules() {
                // For single line if statements we cannot use the same method as for
                // try-catch structures, so we check this case with a precondition.
                // Refer to Single-Line Syntax for further details:
                // https://msdn.microsoft.com/en-us/library/752y8abs.aspx

                // Recognize single line if statements
                RecognizerBase<EVisualBasicParserState> singleLineIfSelector = createRecognizer(
                                start -> start.sequence(IF).skipTo(THEN).repeated(COLON).sequence(NO_NEW_LINE));

                RecognizerBase<EVisualBasicParserState> base = inState(IN_METHOD, IN_SINGLE_LINE_IF)
                                .preCondition(singleLineIfSelector).sequence(IF).createNode(EShallowEntityType.STATEMENT, -1)
                                .skipTo(THEN).parseUntil(IN_SINGLE_LINE_IF).sequenceBefore(EnumSet.of(EOL, ELSE));

                base.sequenceBefore(ELSE).endNodeWithContinuation();
                base.sequence(EOL).endNode();

                // Recognize single line else statements
                RecognizerBase<EVisualBasicParserState> elseRecognizer = createRecognizer(
                                start -> start.sequence(ELSE).repeated(COLON).sequenceBefore(NO_NEW_LINE));

                inState(IN_METHOD, IN_SINGLE_LINE_IF).preCondition(elseRecognizer).sequence(ELSE)
                                .createNode(EShallowEntityType.STATEMENT, -1).parseUntil(IN_SINGLE_LINE_IF).sequence(EOL)
                                .optional(END_IF).endNode();

                // Multi line If Statements
                createBlockRuleWithContinuation(EnumSet.of(IF, ELSEIF, ELSE), EnumSet.of(ELSEIF, ELSE), END_IF);

        }

        /**
         * Create a rule to identify namespaces.
         */
        private void createNamespaceRule() {
                RecognizerBase<EVisualBasicParserState> base = inState(TOP_LEVEL).sequence(NAMESPACE)
                                .createNode(EShallowEntityType.MODULE, SubTypeNames.NAMESPACE, 1);
                skipToEndOfStatement(base).parseUntil(TOP_LEVEL).sequence(END_NAMESPACE).endNode();
        }

        /**
         * Create a rule that matches simple statements.
         */
        private void createSimpleStatementRule() {
                // Local variables either begin with at least one modifier
                RecognizerBase<EVisualBasicParserState> localVariable = inState(IN_METHOD, IN_SINGLE_LINE_IF)
                                .sequence(DECLARATION_MODIFIER).repeated(DECLARATION_MODIFIER).markStart()
                                .createNode(EShallowEntityType.STATEMENT, SubTypeNames.LOCAL_VARIABLE, 0);
                skipToEndOfStatement(localVariable).endNode();

                // Allow a statement to start with DOT, too, because of its use in a
                // WITH statement.
                RecognizerBase<EVisualBasicParserState> simpleStatement = inState(TOP_LEVEL, IN_TYPE, IN_METHOD,
                                IN_SINGLE_LINE_IF).optional(DOT).repeated(DECLARATION_MODIFIER).sequence(STATEMENT_START)
                                                .createNode(EShallowEntityType.STATEMENT, SubTypeNames.SIMPLE_STATEMENT, -1);
                skipToEndOfStatement(simpleStatement).endNode();
        }

        /**
         * Create rules for methods.
         */
        private void createMethodRules() {
                createMethodRule(FUNCTION, END_FUNCTION, IDENTIFIER, SubTypeNames.METHOD);
                createMethodRule(SUB, END_SUB, IDENTIFIER, SubTypeNames.METHOD);
                createMethodRule(SUB, END_SUB, NEW, SubTypeNames.CONSTRUCTOR);

                // Special methods: GET and SET in properties.
                createGetSetRule(GET, END_GET);
                createGetSetRule(SET, END_SET);

                // Operator overloading.
                createOperatorRule();

                // Declare
                RecognizerBase<EVisualBasicParserState> baseRecognizerDeclare = inState(TOP_LEVEL, IN_TYPE)
                                .repeated(DECLARATION_MODIFIER).sequence(ETokenType.DECLARE)
                                // IDENTIFIER needed to match "PtrSafe"
                                .optional(EnumSet.of(ANSI, AUTO, UNICODE, IDENTIFIER)).sequence(EnumSet.of(SUB, FUNCTION)).markStart()
                                .createNode(EShallowEntityType.METHOD, SubTypeNames.DECLARATION, 0);
                skipToEndOfStatement(baseRecognizerDeclare).endNode();
        }

        /**
         * Creates a rule that matches operator overloading structures. They are
         * reported as methods.
         */
        private void createOperatorRule() {
                RecognizerBase<EVisualBasicParserState> base = inState(IN_TYPE).repeated(DECLARATION_MODIFIER)
                                .sequence(OPERATOR).markStart().createNode(EShallowEntityType.METHOD, SubTypeNames.OPERATOR, 0);
                skipToEndOfStatement(base).parseUntil(IN_METHOD).sequence(END_OPERATOR).endNode();

        }

        /**
         * Create the rule for a single getter or setter. The rule is matched inside a
         * type. This means that a property must parse as IN_TYPE.
         */
        private void createGetSetRule(ETokenType startTokenType, ETokenType endTokenType) {
                RecognizerBase<EVisualBasicParserState> base = inState(IN_TYPE).repeated(DECLARATION_MODIFIER).markStart()
                                .sequence(startTokenType)
                                .createNode(EShallowEntityType.METHOD, -1, new PropertyAccessNameResolver<EVisualBasicParserState>());
                skipToEndOfStatement(base).parseUntil(IN_METHOD).sequence(endTokenType).endNode();

        }

        /**
         * Create the rule to match a method that is identified by startTokenType and
         * parses the contents of the method until endTokenType is reached.
         */
        private void createMethodRule(ETokenType startTokenType, ETokenType endTokenType, Object identifierTokenType,
                        String subtypeName) {

                // Classes may define methods with 'MUSTOVERRIDE' that do not have a
                // method body.
                RecognizerBase<EVisualBasicParserState> abstractTypeBase = inState(TOP_LEVEL, IN_TYPE)
                                .repeated(DECLARATION_MODIFIER).sequence(MUSTOVERRIDE).repeated(DECLARATION_MODIFIER)
                                .sequence(startTokenType).sequence(identifierTokenType)
                                .createNode(EShallowEntityType.METHOD, subtypeName, -1);
                skipToEndOfStatement(abstractTypeBase).endNode();

                // Typical method declarations.
                RecognizerBase<EVisualBasicParserState> typeBase = inState(TOP_LEVEL, IN_TYPE);
                typeBase = appendMethodNode(typeBase, startTokenType, identifierTokenType, subtypeName);
                skipToEndOfStatement(typeBase).parseUntil(IN_METHOD).sequence(endTokenType).endNode();

                // For interfaces the methods do not have a body.
                RecognizerBase<EVisualBasicParserState> interfaceBase = inState(IN_INTERFACE);
                interfaceBase = appendMethodNode(interfaceBase, startTokenType, identifierTokenType, subtypeName);
                skipToEndOfStatement(interfaceBase).endNode();

        }

        /**
         * Create rule to match a method that is identified by startTokenType and parses
         * the contents of the method until endTokenType is reached.
         */
        private static RecognizerBase<EVisualBasicParserState> appendMethodNode(
                        RecognizerBase<EVisualBasicParserState> base, ETokenType startTokenType, Object identifierTokenType,
                        String subtypeName) {
                return base.repeated(DECLARATION_MODIFIER).sequence(startTokenType).sequence(identifierTokenType)
                                .createNode(EShallowEntityType.METHOD, subtypeName, -1);
        }

        /**
         * Create rules for type attributes.
         */
        private void createAttributeRules() {
                // Attributes
                RecognizerBase<EVisualBasicParserState> baseRecognizerAttribute = inState(TOP_LEVEL, IN_TYPE)
                                .repeated(DECLARATION_MODIFIER)
                                // Member variables have to start with DIM, if no other
                                // modifier is present
                                .optional(DIM).sequence(IDENTIFIER)
                                .createNode(EShallowEntityType.ATTRIBUTE, SubTypeNames.ATTRIBUTE, -1);
                skipToEndOfStatement(baseRecognizerAttribute).endNode();

                // Delegates
                RecognizerBase<EVisualBasicParserState> baseRecognizerDelegate = inState(TOP_LEVEL, IN_TYPE)
                                .repeated(DECLARATION_MODIFIER).sequence(DELEGATE).markStart()
                                .createNode(EShallowEntityType.ATTRIBUTE, SubTypeNames.DELEGATE, 1);
                skipToEndOfStatement(baseRecognizerDelegate).endNode();
        }

        /**
         * Create rules for classes etc.
         */
        private void createTypeLikeRules() {
                createTypeLikeRule(EShallowEntityType.TYPE, IN_TYPE, CLASS, END_CLASS, SubTypeNames.CLASS);
                createTypeLikeRule(EShallowEntityType.MODULE, IN_TYPE, MODULE, END_MODULE, SubTypeNames.MODULE);
                createTypeLikeRule(EShallowEntityType.TYPE, IN_INTERFACE, INTERFACE, END_INTERFACE, SubTypeNames.INTERFACE);
                createTypeLikeRule(EShallowEntityType.TYPE, IN_TYPE, STRUCTURE, END_STRUCTURE, SubTypeNames.STRUCTURE);
                createTypeLikeRule(EShallowEntityType.TYPE, IN_TYPE, TYPE, END_TYPE, SubTypeNames.TYPE_ALIAS);
        }

        /**
         * Appends a recognizer to the sequence, that repeatedly skips INHERITS and
         * IMPLEMENTS code parts. This is necessary because they may continue a
         * statement in the next line.
         */
        private RecognizerBase<EVisualBasicParserState> appendSkipToEndOfTypeRecognizer(
                        RecognizerBase<EVisualBasicParserState> base) {

                RecognizerBase<EVisualBasicParserState> extendedTypeRecognizer = createRecognizer(
                                start -> start.repeated(EOL).sequence(EnumSet.of(INHERITS, IMPLEMENTS)));
                skipToEndOfStatement(extendedTypeRecognizer);

                return base.repeatedSubRecognizer(extendedTypeRecognizer);
        }

        /**
         * Create a rule for the given type. Modules are treated here as well, as they
         * are syntactically similar to types.
         */
        private void createTypeLikeRule(EShallowEntityType shallowEntityType, EVisualBasicParserState subParseState,
                        ETokenType startTokenType, ETokenType endTokenType, String subtypeName) {

                RecognizerBase<EVisualBasicParserState> base = inState(TOP_LEVEL, IN_TYPE).repeated(DECLARATION_MODIFIER)
                                .sequence(startTokenType, IDENTIFIER).createNode(shallowEntityType, subtypeName, -1);

                appendSkipToEndOfTypeRecognizer(skipToEndOfStatement(base)).parseUntil(subParseState).sequence(endTokenType)
                                .endNode();
        }

        /**
         * Create the rules that recognize meta statements such as imports.
         */
        private void createMetaRules() {

                // Attribute lists
                inAnyState().sequence(LT).createNode(EShallowEntityType.META, SubTypeNames.ANNOTATION, 1)
                                .skipToWithNesting(GT, OPENING_TYPES, CLOSING_TYPES).endNode();

                // Matches attribute and version meta data in e.g. *.bas files
                skipToEndOfStatement(inState(TOP_LEVEL).sequence(IDENTIFIER).createNode(EShallowEntityType.META, -1)).endNode();

                // Imports
                RecognizerBase<EVisualBasicParserState> baseRecognizerImports = inState(TOP_LEVEL).sequence(IMPORTS)
                                .createNode(EShallowEntityType.META, SubTypeNames.IMPORT);
                skipToEndOfStatement(baseRecognizerImports).endNode();

                // Preprocessor directives
                inAnyState().sequence(HASH).createNode(EShallowEntityType.META, "preprocessor directive").skipTo(EOL).endNode();

                // Goto label
                inState(IN_METHOD, IN_SINGLE_LINE_IF).sequence(IDENTIFIER, COLON)
                                .createNode(EShallowEntityType.META, SubTypeNames.LABEL, -2).endNode();

                // Options
                inState(TOP_LEVEL).sequence(OPTION).createNode(EShallowEntityType.META, 0, 1).skipForward(1)
                                // Binary, Text and Off are not scanned as separate keywords.
                                // They are unreserved keywords:
                                // https://msdn.microsoft.com/en-us/library/dd409611.aspx
                                .optional(EnumSet.of(ON, IDENTIFIER))
                                // People might write all options in one line.
                                .optional(COLON).endNode();

                // Form meta data encapsulated by BEGIN and END
                inState(TOP_LEVEL).sequence(BEGIN).createNode(EShallowEntityType.META, SubTypeNames.FORM)
                                .skipToWithNesting(END, BEGIN, END).endNode();
        }

        /**
         * Skip to the end of a statement and return the modified recognizer.
         */
        private RecognizerBase<EVisualBasicParserState> skipToEndOfStatement(RecognizerBase<EVisualBasicParserState> base) {
                // Statements in VB.NET end with the first EOL that is encountered
                // except the compiler can perform Implicit Line Conversion:
                // https://msdn.microsoft.com/en-us/library/865x40k4.aspx

                // Save the reference to the skipBeforeWithNesting recognizer, as
                // this gives the same result as using the reference to the empty
                // recognizer.
                RecognizerBase<EVisualBasicParserState> statementContinuationRecognizer = createRecognizer(start -> {
                        RecognizerBase<EVisualBasicParserState> prefix = start
                                        .skipBeforeWithNesting(STATEMENT_CONTINUATION_CANDIDATES, OPENING_TYPES, CLOSING_TYPES);
                        prefix.sequence(STATEMENT_CONTINUATION_FOLLOWING, EOL);
                        prefix.sequence(STATEMENT_CONTINUATION_BOTH);
                        prefix.sequence(EOL).sequenceBefore(STATEMENT_CONTINUATION_PRECEDING);
                });

                return base.repeatedSubRecognizer(statementContinuationRecognizer)
                                .skipBeforeWithNesting(STATEMENT_INTERRUPT_TYPES, OPENING_TYPES, CLOSING_TYPES);
        }
}