/*

 * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.tools.javac.parser;

import java.util.*;

import com.sun.source.tree.MemberReferenceTree.ReferenceMode;

import com.sun.tools.javac.code.*;

import com.sun.tools.javac.parser.Tokens.*;

import com.sun.tools.javac.parser.Tokens.Comment.CommentStyle;

import com.sun.tools.javac.tree.*;

import com.sun.tools.javac.tree.JCTree.*;

import com.sun.tools.javac.util.*;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

import com.sun.tools.javac.util.List;

import static com.sun.tools.javac.parser.Tokens.TokenKind.*;

import static com.sun.tools.javac.parser.Tokens.TokenKind.ASSERT;

import static com.sun.tools.javac.parser.Tokens.TokenKind.CASE;

import static com.sun.tools.javac.parser.Tokens.TokenKind.CATCH;

import static com.sun.tools.javac.parser.Tokens.TokenKind.EQ;

import static com.sun.tools.javac.parser.Tokens.TokenKind.GT;

import static com.sun.tools.javac.parser.Tokens.TokenKind.IMPORT;

import static com.sun.tools.javac.parser.Tokens.TokenKind.LT;

import static com.sun.tools.javac.tree.JCTree.Tag.*;

/** The parser maps a token sequence into an abstract syntax

 *  tree. It operates by recursive descent, with code derived

 *  systematically from an LL(1) grammar. For efficiency reasons, an

 *  operator precedence scheme is used for parsing binary operation

 *  expressions.

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class JavacParser implements Parser {

    /** The number of precedence levels of infix operators.

     */

    private static final int infixPrecedenceLevels = 10;

    /** The scanner used for lexical analysis.

     */

    protected Lexer S;

    /** The factory to be used for abstract syntax tree construction.

     */

    protected TreeMaker F;

    /** The log to be used for error diagnostics.

     */

    private Log log;

    /** The Source language setting. */

    private Source source;

    /** The name table. */

    private Names names;

    /** End position mappings container */

    // Because of javac's limited lookahead, some contexts are ambiguous in

    // the presence of type annotations even though they are not ambiguous

    // in the absence of type annotations.  Consider this code:

    //   void m(String [] m) { }

    //   void m(String ... m) { }

    // After parsing "String", javac calls bracketsOpt which immediately

    // returns if the next character is not '['.  Similarly, javac can see

    // if the next token is ... and in that case parse an ellipsis.  But in

    // the presence of type annotations:

    //   void m(String @A [] m) { }

    //   void m(String @A ... m) { }

    // no finite lookahead is enough to determine whether to read array

    // levels or an ellipsis.  Furthermore, if you call bracketsOpt, then

    // bracketsOpt first reads all the leading annotations and only then

    // discovers that it needs to fail.  bracketsOpt needs a way to push

    // back the extra annotations that it read.  (But, bracketsOpt should

    // not *always* be allowed to push back extra annotations that it finds

    // -- in most contexts, any such extra annotation is an error.

    //

    // The following two variables permit type annotations that have

    // already been read to be stored for later use.  Alternate

    // implementations are possible but would cause much larger changes to

    // the parser.

    /** Type annotations that have already been read but have not yet been used. **/

    private List<JCAnnotation> typeAnnotationsPushedBack = List.nil();

    /**

     * If the parser notices extra annotations, then it either immediately

     * issues an error (if this variable is false) or places the extra

     * annotations in variable typeAnnotationsPushedBack (if this variable

     * is true).

     */

    private boolean permitTypeAnnotationsPushBack = false;

    interface ErrorRecoveryAction {

        JCTree doRecover(JavacParser parser);

    }

    enum BasicErrorRecoveryAction implements ErrorRecoveryAction {

        BLOCK_STMT {public JCTree doRecover(JavacParser parser) { return parser.parseStatementAsBlock(); }},

        CATCH_CLAUSE {public JCTree doRecover(JavacParser parser) { return parser.catchClause(); }}

    }

    /** Construct a parser from a given scanner, tree factory and log.

     */

    protected JavacParser(ParserFactory fac,

                     Lexer S,

                     boolean keepDocComments,

                     boolean keepLineMap,

                     boolean keepEndPositions) {

        this.S = S;

        nextToken(); // prime the pump

        this.F = fac.F;

        this.log = fac.log;

        this.names = fac.names;

        this.source = fac.source;

        this.allowTWR = source.allowTryWithResources();

        this.allowEffectivelyFinalVariablesInTWR =

                source.allowEffectivelyFinalVariablesInTryWithResources();

        this.allowDiamond = source.allowDiamond();

        this.allowMulticatch = source.allowMulticatch();

        this.allowStringFolding = fac.options.getBoolean("allowStringFolding", true);

        this.allowLambda = source.allowLambda();

        this.allowMethodReferences = source.allowMethodReferences();

        this.allowDefaultMethods = source.allowDefaultMethods();

        this.allowStaticInterfaceMethods = source.allowStaticInterfaceMethods();

        this.allowIntersectionTypesInCast = source.allowIntersectionTypesInCast();

        this.allowTypeAnnotations = source.allowTypeAnnotations();

        this.allowAnnotationsAfterTypeParams = source.allowAnnotationsAfterTypeParams();

        this.allowUnderscoreIdentifier = source.allowUnderscoreIdentifier();

        this.keepDocComments = keepDocComments;

        docComments = newDocCommentTable(keepDocComments, fac);

        this.keepLineMap = keepLineMap;

        this.errorTree = F.Erroneous();

        endPosTable = newEndPosTable(keepEndPositions);

    }

    protected AbstractEndPosTable newEndPosTable(boolean keepEndPositions) {

        return  keepEndPositions

                ? new SimpleEndPosTable(this)

                : new EmptyEndPosTable(this);

    }

    protected DocCommentTable newDocCommentTable(boolean keepDocComments, ParserFactory fac) {

        return keepDocComments ? new LazyDocCommentTable(fac) : null;

    }

    /** Switch: Should diamond operator be recognized?

     */

    boolean allowDiamond;

    /** Switch: Should multicatch clause be accepted?

     */

    boolean allowMulticatch;

    /** Switch: should we recognize try-with-resources?

     */

    boolean allowTWR;

    /** Switch: should we allow (effectively) final variables as resources in try-with-resources?

     */

    boolean allowEffectivelyFinalVariablesInTWR;

    /** Switch: should we fold strings?

     */

    boolean allowStringFolding;

    /** Switch: should we recognize lambda expressions?

     */

    boolean allowLambda;

    /** Switch: should we allow method/constructor references?

     */

    boolean allowMethodReferences;

    /** Switch: should we allow default methods in interfaces?

     */

    boolean allowDefaultMethods;

    /** Switch: should we allow static methods in interfaces?

     */

    boolean allowStaticInterfaceMethods;

    /** Switch: should we allow intersection types in cast?

     */

    boolean allowIntersectionTypesInCast;

    /** Switch: should we keep docComments?

     */

    boolean keepDocComments;

    /** Switch: should we keep line table?

     */

    boolean keepLineMap;

    /** Switch: should we recognize type annotations?

     */

    boolean allowTypeAnnotations;

    /** Switch: should we allow annotations after the method type parameters?

     */

    boolean allowAnnotationsAfterTypeParams;

    /** Switch: should we allow '_' as an identifier?

     */

    boolean allowUnderscoreIdentifier;

    /** Switch: is "this" allowed as an identifier?

     * This is needed to parse receiver types.

     */

    boolean allowThisIdent;

    /** The type of the method receiver, as specified by a first "this" parameter.

     */

    JCVariableDecl receiverParam;

    /** When terms are parsed, the mode determines which is expected:

     *     mode = EXPR        : an expression

     *     mode = TYPE        : a type

     *     mode = NOPARAMS    : no parameters allowed for type

     *     mode = TYPEARG     : type argument

     */

    protected static final int EXPR = 0x1;

    protected static final int TYPE = 0x2;

    protected static final int NOPARAMS = 0x4;

    protected static final int TYPEARG = 0x8;

    protected static final int DIAMOND = 0x10;

    /** The current mode.

     */

    protected int mode = 0;

    /** The mode of the term that was parsed last.

     */

    protected int lastmode = 0;

    /* ---------- token management -------------- */

    protected Token token;

    public Token token() {

        return token;

    }

    public void nextToken() {

        S.nextToken();

        token = S.token();

    }

    protected boolean peekToken(Filter<TokenKind> tk) {

        return peekToken(0, tk);

    }

    protected boolean peekToken(int lookahead, Filter<TokenKind> tk) {

        return tk.accepts(S.token(lookahead + 1).kind);

    }

    protected boolean peekToken(Filter<TokenKind> tk1, Filter<TokenKind> tk2) {

        return peekToken(0, tk1, tk2);

    }

    protected boolean peekToken(int lookahead, Filter<TokenKind> tk1, Filter<TokenKind> tk2) {

        return tk1.accepts(S.token(lookahead + 1).kind) &&

                tk2.accepts(S.token(lookahead + 2).kind);

    }

    protected boolean peekToken(Filter<TokenKind> tk1, Filter<TokenKind> tk2, Filter<TokenKind> tk3) {

        return peekToken(0, tk1, tk2, tk3);

    }

    protected boolean peekToken(int lookahead, Filter<TokenKind> tk1, Filter<TokenKind> tk2, Filter<TokenKind> tk3) {

        return tk1.accepts(S.token(lookahead + 1).kind) &&

                tk2.accepts(S.token(lookahead + 2).kind) &&

                tk3.accepts(S.token(lookahead + 3).kind);

    }

    @SuppressWarnings("unchecked")

    protected boolean peekToken(Filter<TokenKind>... kinds) {

        return peekToken(0, kinds);

    }

    @SuppressWarnings("unchecked")

    protected boolean peekToken(int lookahead, Filter<TokenKind>... kinds) {

        for (; lookahead < kinds.length ; lookahead++) {

            if (!kinds[lookahead].accepts(S.token(lookahead + 1).kind)) {

                return false;

            }

        }

        return true;

    }

    /* ---------- error recovery -------------- */

    private JCErroneous errorTree;

    /** Skip forward until a suitable stop token is found.

     */

    protected void skip(boolean stopAtImport, boolean stopAtMemberDecl, boolean stopAtIdentifier, boolean stopAtStatement) {

         while (true) {

             switch (token.kind) {

                case SEMI:

                    nextToken();

                    return;

                case PUBLIC:

                case FINAL:

                case ABSTRACT:

                case MONKEYS_AT:

                case EOF:

                case CLASS:

                case INTERFACE:

                case ENUM:

                    return;

                case IMPORT:

                    if (stopAtImport)

                        return;

                    break;

                case LBRACE:

                case RBRACE:

                case PRIVATE:

                case PROTECTED:

                case STATIC:

                case TRANSIENT:

                case NATIVE:

                case VOLATILE:

                case SYNCHRONIZED:

                case STRICTFP:

                case LT:

                case BYTE:

                case SHORT:

                case CHAR:

                case INT:

                case LONG:

                case FLOAT:

                case DOUBLE:

                case BOOLEAN:

                case VOID:

                    if (stopAtMemberDecl)

                        return;

                    break;

                case UNDERSCORE:

                case IDENTIFIER:

                   if (stopAtIdentifier)

                        return;

                    break;

                case CASE:

                case DEFAULT:

                case IF:

                case FOR:

                case WHILE:

                case DO:

                case TRY:

                case SWITCH:

                case RETURN:

                case THROW:

                case BREAK:

                case CONTINUE:

                case ELSE:

                case FINALLY:

                case CATCH:

                case THIS:

                case SUPER:

                case NEW:

                    if (stopAtStatement)

                        return;

                    break;

                case ASSERT:

                    if (stopAtStatement)

                        return;

                    break;

            }

            nextToken();

        }

    }

    protected JCErroneous syntaxError(int pos, String key, TokenKind... args) {

        return syntaxError(pos, List.<JCTree>nil(), key, args);

    }

    protected JCErroneous syntaxError(int pos, List<JCTree> errs, String key, TokenKind... args) {

        setErrorEndPos(pos);

        JCErroneous err = F.at(pos).Erroneous(errs);

        reportSyntaxError(err, key, (Object[])args);

        if (errs != null) {

            JCTree last = errs.last();

            if (last != null)

                storeEnd(last, pos);

        }

        return toP(err);

    }

    private static final int RECOVERY_THRESHOLD = 50;

    private int errorPos = Position.NOPOS;

    private int count = 0;

    /**

     * Report a syntax using the given the position parameter and arguments,

     * unless one was already reported at the same position.

     */

    protected void reportSyntaxError(int pos, String key, Object... args) {

        JCDiagnostic.DiagnosticPosition diag = new JCDiagnostic.SimpleDiagnosticPosition(pos);

        reportSyntaxError(diag, key, args);

    }

    /**

     * Report a syntax error using the given DiagnosticPosition object and

     * arguments, unless one was already reported at the same position.

     */

    protected void reportSyntaxError(JCDiagnostic.DiagnosticPosition diagPos, String key, Object... args) {

        int pos = diagPos.getPreferredPosition();

        if (pos > S.errPos() || pos == Position.NOPOS) {

            if (token.kind == EOF) {

                error(diagPos, "premature.eof");

            } else {

                error(diagPos, key, args);

            }

        }

        S.errPos(pos);

        if (token.pos == errorPos) {

            //check for a possible infinite loop in parsing:

            Assert.check(count++ < RECOVERY_THRESHOLD);

        } else {

            count = 0;

            errorPos = token.pos;

        }

    }

    /** Generate a syntax error at current position unless one was already

     *  reported at the same position.

     */

    protected JCErroneous syntaxError(String key) {

        return syntaxError(token.pos, key);

    }

    /** Generate a syntax error at current position unless one was

     *  already reported at the same position.

     */

    protected JCErroneous syntaxError(String key, TokenKind arg) {

        return syntaxError(token.pos, key, arg);

    }

    /** If next input token matches given token, skip it, otherwise report

     *  an error.

     */

    public void accept(TokenKind tk) {

        if (token.kind == tk) {

            nextToken();

        } else {

            setErrorEndPos(token.pos);

            reportSyntaxError(S.prevToken().endPos, "expected", tk);

        }

    }

    /** Report an illegal start of expression/type error at given position.

     */

    JCExpression illegal(int pos) {

        setErrorEndPos(pos);

        if ((mode & EXPR) != 0)

            return syntaxError(pos, "illegal.start.of.expr");

        else

            return syntaxError(pos, "illegal.start.of.type");

    }

    /** Report an illegal start of expression/type error at current position.

     */

    JCExpression illegal() {