/*

 * Copyright (c) 1999, 2013, 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.tree;

import java.io.IOException;

import java.io.StringWriter;

import java.util.*;

import javax.lang.model.element.Modifier;

import javax.lang.model.type.TypeKind;

import javax.tools.JavaFileObject;

import com.sun.source.tree.*;

import com.sun.source.tree.LambdaExpressionTree.BodyKind;

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

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

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

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

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

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

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

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

/**

 * Root class for abstract syntax tree nodes. It provides definitions

 * for specific tree nodes as subclasses nested inside.

 *

 * <p>Each subclass is highly standardized.  It generally contains

 * only tree fields for the syntactic subcomponents of the node.  Some

 * classes that represent identifier uses or definitions also define a

 * Symbol field that denotes the represented identifier.  Classes for

 * non-local jumps also carry the jump target as a field.  The root

 * class Tree itself defines fields for the tree's type and position.

 * No other fields are kept in a tree node; instead parameters are

 * passed to methods accessing the node.

 *

 * <p>Except for the methods defined by com.sun.source, the only

 * method defined in subclasses is `visit' which applies a given

 * visitor to the tree. The actual tree processing is done by visitor

 * classes in other packages. The abstract class Visitor, as well as

 * an Factory interface for trees, are defined as inner classes in

 * Tree.

 *

 * <p>To avoid ambiguities with the Tree API in com.sun.source all sub

 * classes should, by convention, start with JC (javac).

 *

 * <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>

 *

 * @see TreeMaker

 * @see TreeInfo

 * @see TreeTranslator

 * @see Pretty

 */

public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {

    /* Tree tag values, identifying kinds of trees */

    public enum Tag {

        /** For methods that return an invalid tag if a given condition is not met

         */

        NO_TAG,

        /** Toplevel nodes, of type TopLevel, representing entire source files.

        */

        TOPLEVEL,

        /** Import clauses, of type Import.

         */

        IMPORT,

        /** Class definitions, of type ClassDef.

         */

        CLASSDEF,

        /** Method definitions, of type MethodDef.

         */

        METHODDEF,

        /** Variable definitions, of type VarDef.

         */

        VARDEF,

        /** The no-op statement ";", of type Skip

         */

        SKIP,

        /** Blocks, of type Block.

         */

        BLOCK,

        /** Do-while loops, of type DoLoop.

         */

        DOLOOP,

        /** While-loops, of type WhileLoop.

         */

        WHILELOOP,

        /** For-loops, of type ForLoop.

         */

        FORLOOP,

        /** Foreach-loops, of type ForeachLoop.

         */

        FOREACHLOOP,

        /** Labelled statements, of type Labelled.

         */

        LABELLED,

        /** Switch statements, of type Switch.

         */

        SWITCH,

        /** Case parts in switch statements, of type Case.

         */

        CASE,

        /** Synchronized statements, of type Synchonized.

         */

        SYNCHRONIZED,

        /** Try statements, of type Try.

         */

        TRY,

        /** Catch clauses in try statements, of type Catch.

         */

        CATCH,

        /** Conditional expressions, of type Conditional.

         */

        CONDEXPR,

        /** Conditional statements, of type If.

         */

        IF,

        /** Expression statements, of type Exec.

         */

        EXEC,

        /** Break statements, of type Break.

         */

        BREAK,

        /** Continue statements, of type Continue.

         */

        CONTINUE,

        /** Return statements, of type Return.

         */

        RETURN,

        /** Throw statements, of type Throw.

         */

        THROW,

        /** Assert statements, of type Assert.

         */

        ASSERT,

        /** Method invocation expressions, of type Apply.

         */

        APPLY,

        /** Class instance creation expressions, of type NewClass.

         */

        NEWCLASS,

        /** Array creation expressions, of type NewArray.

         */

        NEWARRAY,

        /** Lambda expression, of type Lambda.

         */

        LAMBDA,

        /** Parenthesized subexpressions, of type Parens.

         */

        PARENS,

        /** Assignment expressions, of type Assign.

         */

        ASSIGN,

        /** Type cast expressions, of type TypeCast.

         */

        TYPECAST,

        /** Type test expressions, of type TypeTest.

         */

        TYPETEST,

        /** Indexed array expressions, of type Indexed.

         */

        INDEXED,

        /** Selections, of type Select.

         */

        SELECT,

        /** Member references, of type Reference.

         */

        REFERENCE,

        /** Simple identifiers, of type Ident.

         */

        IDENT,

        /** Literals, of type Literal.

         */

        LITERAL,

        /** Basic type identifiers, of type TypeIdent.

         */

        TYPEIDENT,

        /** Array types, of type TypeArray.

         */

        TYPEARRAY,

        /** Parameterized types, of type TypeApply.

         */

        TYPEAPPLY,

        /** Union types, of type TypeUnion.

         */

        TYPEUNION,

        /** Intersection types, of type TypeIntersection.

         */

        TYPEINTERSECTION,

        /** Formal type parameters, of type TypeParameter.

         */

        TYPEPARAMETER,

        /** Type argument.

         */

        WILDCARD,

        /** Bound kind: extends, super, exact, or unbound

         */

        TYPEBOUNDKIND,

        /** metadata: Annotation.

         */

        ANNOTATION,

        /** metadata: Type annotation.

         */

        TYPE_ANNOTATION,

        /** metadata: Modifiers

         */

        MODIFIERS,

        /** An annotated type tree.

         */

        ANNOTATED_TYPE,

        /** Error trees, of type Erroneous.

         */

        ERRONEOUS,

        /** Unary operators, of type Unary.

         */

        POS,                             // +

        NEG,                             // -

        NOT,                             // !

        COMPL,                           // ~

        PREINC,                          // ++ _

        PREDEC,                          // -- _

        POSTINC,                         // _ ++

        POSTDEC,                         // _ --

        /** unary operator for null reference checks, only used internally.

         */

        NULLCHK,

        /** Binary operators, of type Binary.

         */

        OR,                              // ||

        AND,                             // &&

        BITOR,                           // |

        BITXOR,                          // ^

        BITAND,                          // &

        EQ,                              // ==

        NE,                              // !=

        LT,                              // <

        GT,                              // >

        LE,                              // <=

        GE,                              // >=

        SL,                              // <<

        SR,                              // >>

        USR,                             // >>>

        PLUS,                            // +

        MINUS,                           // -

        MUL,                             // *

        DIV,                             // /

        MOD,                             // %

        /** Assignment operators, of type Assignop.

         */

        BITOR_ASG(BITOR),                // |=

        BITXOR_ASG(BITXOR),              // ^=

        BITAND_ASG(BITAND),              // &=

        SL_ASG(SL),                      // <<=

        SR_ASG(SR),                      // >>=

        USR_ASG(USR),                    // >>>=

        PLUS_ASG(PLUS),                  // +=

        MINUS_ASG(MINUS),                // -=

        MUL_ASG(MUL),                    // *=

        DIV_ASG(DIV),                    // /=

        MOD_ASG(MOD),                    // %=

        /** A synthetic let expression, of type LetExpr.

         */

        LETEXPR;                         // ala scheme

        private final Tag noAssignTag;

        private static final int numberOfOperators = MOD.ordinal() - POS.ordinal() + 1;

        private Tag(Tag noAssignTag) {

            this.noAssignTag = noAssignTag;

        }

        private Tag() {

            this(null);

        }

        public static int getNumberOfOperators() {

            return numberOfOperators;

        }

        public Tag noAssignOp() {

            if (noAssignTag != null)

                return noAssignTag;

            throw new AssertionError("noAssignOp() method is not available for non assignment tags");

        }

        public boolean isPostUnaryOp() {

            return (this == POSTINC || this == POSTDEC);

        }

        public boolean isIncOrDecUnaryOp() {

            return (this == PREINC || this == PREDEC || this == POSTINC || this == POSTDEC);

        }

        public boolean isAssignop() {

            return noAssignTag != null;

        }

        public int operatorIndex() {

            return (this.ordinal() - POS.ordinal());

        }

    }

    /* The (encoded) position in the source file. @see util.Position.

     */

    public int pos;

    /* The type of this node.

     */

    public Type type;

    /* The tag of this node -- one of the constants declared above.

     */

    public abstract Tag getTag();

    /* Returns true if the tag of this node is equals to tag.

     */

    public boolean hasTag(Tag tag) {

        return tag == getTag();

    }

    /** Convert a tree to a pretty-printed string. */

    @Override

    public String toString() {

        StringWriter s = new StringWriter();

        try {

            new Pretty(s, false).printExpr(this);

        }

        catch (IOException e) {

            // should never happen, because StringWriter is defined

            // never to throw any IOExceptions

            throw new AssertionError(e);

        }

        return s.toString();

    }

    /** Set position field and return this tree.

     */

    public JCTree setPos(int pos) {

        this.pos = pos;

        return this;

    }

    /** Set type field and return this tree.

     */

    public JCTree setType(Type type) {

        this.type = type;

        return this;

    }

    /** Visit this tree with a given visitor.

     */

    public abstract void accept(Visitor v);

    public abstract <R,D> R accept(TreeVisitor<R,D> v, D d);

    /** Return a shallow copy of this tree.

     */

    @Override

    public Object clone() {

        try {

            return super.clone();

        } catch(CloneNotSupportedException e) {

            throw new RuntimeException(e);

        }

    }

    /** Get a default position for this tree node.

     */

    public DiagnosticPosition pos() {

        return this;

    }

    // for default DiagnosticPosition

    public JCTree getTree() {

        return this;

    }

    // for default DiagnosticPosition

    public int getStartPosition() {

        return TreeInfo.getStartPos(this);

    }

    // for default DiagnosticPosition

    public int getPreferredPosition() {

        return pos;

    }

    // for default DiagnosticPosition

    public int getEndPosition(EndPosTable endPosTable) {

        return TreeInfo.getEndPos(this, endPosTable);

    }

    /**

     * Everything in one source file is kept in a {@linkplain JCCompilationUnit} structure.

     */

    public static class JCCompilationUnit extends JCTree implements CompilationUnitTree {

        public List<JCAnnotation> packageAnnotations;

        /** The tree representing the package clause. */

        public JCExpression pid;

        /** All definitions in this file (ClassDef, Import, and Skip) */

        public List<JCTree> defs;

        /* The source file name. */

        public JavaFileObject sourcefile;

        /** The package to which this compilation unit belongs. */

        public PackageSymbol packge;

        /** A scope for all named imports. */

        public ImportScope namedImportScope;

        /** A scope for all import-on-demands. */

        public StarImportScope starImportScope;

        /** Line starting positions, defined only if option -g is set. */

        public Position.LineMap lineMap = null;

        /** A table that stores all documentation comments indexed by the tree

         * nodes they refer to. defined only if option -s is set. */

        public DocCommentTable docComments = null;