CloneSet6

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AnnotationTypeMemberDeclaration.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ArrayAccess.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ArrayAccess.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Assignment.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Assignment.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CastExpression.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ConditionalExpression.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ConditionalExpression.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ConditionalExpression.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DoStatement.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/EnhancedForStatement.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/EnumConstantDeclaration.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/FieldAccess.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/FieldAccess.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IfStatement.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/InfixExpression.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/InfixExpression.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/InstanceofExpression.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/LabeledStatement.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MemberRef.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MemberValuePair.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodDeclaration.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodInvocation.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodRef.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PackageDeclaration.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ParenthesizedExpression.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PostfixExpression.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PrefixExpression.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/QualifiedName.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/QualifiedName.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/QualifiedType.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SimpleType.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SingleMemberAnnotation.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SingleVariableDeclaration.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SuperMethodInvocation.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SwitchStatement.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SynchronizedStatement.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ThrowStatement.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/VariableDeclarationFragment.java

plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/WhileStatement.java

        /**
         * Returns the name of the annotation type member declared in this declaration.
         * 
         * @return the member name node
         */
        public SimpleName getName() {
                if (this.memberName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.memberName == null) {
                                        preLazyInit();
                                        this.memberName = new SimpleName(this.ast);
                                        postLazyInit(this.memberName, NAME_PROPERTY);
                                }
                        }
                }
                return this.memberName;
        }

        /**
         * Sets the name of the annotation type member declared in this declaration to the
         * given name.
         * 
         * @param memberName the new member name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(SimpleName memberName) {
                if (memberName == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.memberName;
                preReplaceChild(oldChild, memberName, NAME_PROPERTY);
                this.memberName = memberName;
                postReplaceChild(oldChild, memberName, NAME_PROPERTY);
        }

        /**
         * Returns the array expression of this array access expression.
         * 
         * @return the array expression node
         */
        public Expression getArray() {
                if (this.arrayExpression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.arrayExpression == null) {
                                        preLazyInit();
                                        this.arrayExpression = new SimpleName(this.ast);
                                        postLazyInit(this.arrayExpression, ARRAY_PROPERTY);
                                }
                        }
                }
                return this.arrayExpression;
        }

        /**
         * Sets the array expression of this array access expression.
         * 
         * @param expression the array expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setArray(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                // an ArrayAccess may occur inside an Expression
                // must check cycles
                ASTNode oldChild = this.arrayExpression;
                preReplaceChild(oldChild, expression, ARRAY_PROPERTY);
                this.arrayExpression = expression;
                postReplaceChild(oldChild, expression, ARRAY_PROPERTY);
        }

        /**
         * Returns the index expression of this array access expression.
         * 
         * @return the index expression node
         */
        public Expression getIndex() {
                if (this.indexExpression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.indexExpression == null) {
                                        preLazyInit();
                                        this.indexExpression = new SimpleName(this.ast);
                                        postLazyInit(this.indexExpression, INDEX_PROPERTY);
                                }
                        }
                }
                return this.indexExpression;
        }

        /**
         * Sets the index expression of this array access expression.
         * 
         * @param expression the index expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setIndex(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                // an ArrayAccess may occur inside an Expression
                // must check cycles
                ASTNode oldChild = this.indexExpression;
                preReplaceChild(oldChild, expression, INDEX_PROPERTY);
                this.indexExpression = expression;
                postReplaceChild(oldChild, expression, INDEX_PROPERTY);
        }

        /**
         * Returns the left hand side of this assignment expression.
         * 
         * @return the left hand side node
         */
        public Expression getLeftHandSide() {
                if (this.leftHandSide ==  null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.leftHandSide == null) {
                                        preLazyInit();
                                        this.leftHandSide = new SimpleName(this.ast);
                                        postLazyInit(this.leftHandSide, LEFT_HAND_SIDE_PROPERTY);
                                }
                        }
                }
                return this.leftHandSide;
        }

        /**
         * Sets the left hand side of this assignment expression.
         * 
         * @param expression the left hand side node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setLeftHandSide(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                // an Assignment may occur inside a Expression - must check cycles
                ASTNode oldChild = this.leftHandSide;
                preReplaceChild(oldChild, expression, LEFT_HAND_SIDE_PROPERTY);
                this.leftHandSide = expression;
                postReplaceChild(oldChild, expression, LEFT_HAND_SIDE_PROPERTY);
        }

        /**
         * Returns the right hand side of this assignment expression.
         * 
         * @return the right hand side node
         */
        public Expression getRightHandSide() {
                if (this.rightHandSide ==  null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.rightHandSide == null) {
                                        preLazyInit();
                                        this.rightHandSide = new SimpleName(this.ast);
                                        postLazyInit(this.rightHandSide, RIGHT_HAND_SIDE_PROPERTY);
                                }
                        }
                }
                return this.rightHandSide;
        }

        /**
         * Sets the right hand side of this assignment expression.
         * 
         * @param expression the right hand side node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setRightHandSide(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                // an Assignment may occur inside a Expression - must check cycles
                ASTNode oldChild = this.rightHandSide;
                preReplaceChild(oldChild, expression, RIGHT_HAND_SIDE_PROPERTY);
                this.rightHandSide = expression;
                postReplaceChild(oldChild, expression, RIGHT_HAND_SIDE_PROPERTY);
        }

        /**
         * Returns the expression of this cast expression.
         * 
         * @return the expression node
         */
        public Expression getExpression() {
                if (this.expression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.expression == null) {
                                        preLazyInit();
                                        this.expression = new SimpleName(this.ast);
                                        postLazyInit(this.expression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.expression;
        }

        /**
         * Sets the expression of this cast expression.
         * 
         * @param expression the new expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.expression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.expression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

        /**
         * Returns the condition of this conditional expression.
         * 
         * @return the condition node
         */
        public Expression getExpression() {
                if (this.conditionExpression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.conditionExpression == null) {
                                        preLazyInit();
                                        this.conditionExpression = new SimpleName(this.ast);
                                        postLazyInit(this.conditionExpression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.conditionExpression;
        }

        /**
         * Sets the condition of this conditional expression.
         * 
         * @param expression the condition node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.conditionExpression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.conditionExpression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

        /**
         * Returns the "then" part of this conditional expression.
         * 
         * @return the "then" expression node
         */
        public Expression getThenExpression() {
                if (this.thenExpression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.thenExpression == null) {
                                        preLazyInit();
                                        this.thenExpression = new SimpleName(this.ast);
                                        postLazyInit(this.thenExpression, THEN_EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.thenExpression;
        }

        /**
         * Sets the "then" part of this conditional expression.
         * 
         * @param expression the "then" expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setThenExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.thenExpression;
                preReplaceChild(oldChild, expression, THEN_EXPRESSION_PROPERTY);
                this.thenExpression = expression;
                postReplaceChild(oldChild, expression, THEN_EXPRESSION_PROPERTY);
        }

        /**
         * Returns the "else" part of this conditional expression.
         * 
         * @return the "else" expression node
         */
        public Expression getElseExpression() {
                if (this.elseExpression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.elseExpression == null) {
                                        preLazyInit();
                                        this.elseExpression = new SimpleName(this.ast);
                                        postLazyInit(this.elseExpression, ELSE_EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.elseExpression;
        }

        /**
         * Sets the "else" part of this conditional expression.
         * 
         * @param expression the "else" expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setElseExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.elseExpression;
                preReplaceChild(oldChild, expression, ELSE_EXPRESSION_PROPERTY);
                this.elseExpression = expression;
                postReplaceChild(oldChild, expression, ELSE_EXPRESSION_PROPERTY);
        }

        /**
         * Returns the expression of this do statement.
         * 
         * @return the expression node
         */
        public Expression getExpression() {
                if (this.expression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.expression == null) {
                                        preLazyInit();
                                        this.expression = new SimpleName(this.ast);
                                        postLazyInit(this.expression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.expression;
        }

        /**
         * Sets the expression of this do statement.
         * 
         * @param expression the expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.expression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.expression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

        /**
         * Returns the expression of this enhanced for statement.
         * 
         * @return the expression node
         */
        public Expression getExpression() {
                if (this.expression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.expression == null) {
                                        preLazyInit();
                                        this.expression = new SimpleName(this.ast);
                                        postLazyInit(this.expression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.expression;
        }

        /**
         * Sets the expression of this enhanced for statement.
         * 
         * @param expression the new expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.expression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.expression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

        /**
         * Returns the name of the constant declared in this enum declaration.
         * 
         * @return the constant name node
         */
        public SimpleName getName() {
                if (this.constantName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.constantName == null) {
                                        preLazyInit();
                                        this.constantName = new SimpleName(this.ast);
                                        postLazyInit(this.constantName, NAME_PROPERTY);
                                }
                        }
                }
                return this.constantName;
        }

        /**
         * Sets the name of the constant declared in this enum declaration to the
         * given name.
         * 
         * @param constantName the new constant name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(SimpleName constantName) {
                if (constantName == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.constantName;
                preReplaceChild(oldChild, constantName, NAME_PROPERTY);
                this.constantName = constantName;
                postReplaceChild(oldChild, constantName, NAME_PROPERTY);
        }

        /**
         * Returns the expression of this field access expression.
         * 
         * @return the expression node
         */
        public Expression getExpression() {
                if (this.expression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.expression == null) {
                                        preLazyInit();
                                        this.expression = new SimpleName(this.ast);
                                        postLazyInit(this.expression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.expression;
        }

        /**
         * Sets the expression of this field access expression.
         * 
         * @param expression the new expression
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.expression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.expression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

        /**
         * Returns the name of the field accessed in this field access expression.
         * 
         * @return the field name
         */
        public SimpleName getName() {
                if (this.fieldName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.fieldName == null) {
                                        preLazyInit();
                                        this.fieldName = new SimpleName(this.ast);
                                        postLazyInit(this.fieldName, NAME_PROPERTY);
                                }
                        }
                }
                return this.fieldName;
        }

        /**
         * Sets the name of the field accessed in this field access expression.
         * 
         * @param fieldName the field name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(SimpleName fieldName) {
                if (fieldName == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.fieldName;
                preReplaceChild(oldChild, fieldName, NAME_PROPERTY);
                this.fieldName = fieldName;
                postReplaceChild(oldChild, fieldName, NAME_PROPERTY);
        }

        /**
         * Returns the expression of this if statement.
         * 
         * @return the expression node
         */
        public Expression getExpression() {
                if (this.expression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.expression == null) {
                                        preLazyInit();
                                        this.expression = new SimpleName(this.ast);
                                        postLazyInit(this.expression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.expression;
        }

        /**
         * Sets the condition of this if statement.
         * 
         * @param expression the expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.expression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.expression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

        /**
         * Returns the left operand of this infix expression.
         * 
         * @return the left operand node
         */
        public Expression getLeftOperand() {
                if (this.leftOperand ==  null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.leftOperand == null) {
                                        preLazyInit();
                                        this.leftOperand = new SimpleName(this.ast);
                                        postLazyInit(this.leftOperand, LEFT_OPERAND_PROPERTY);
                                }
                        }
                }
                return this.leftOperand;
        }

        /**
         * Sets the left operand of this infix expression.
         * 
         * @param expression the left operand node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setLeftOperand(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.leftOperand;
                preReplaceChild(oldChild, expression, LEFT_OPERAND_PROPERTY);
                this.leftOperand = expression;
                postReplaceChild(oldChild, expression, LEFT_OPERAND_PROPERTY);
        }

        /**
         * Returns the right operand of this infix expression.
         * 
         * @return the right operand node
         */
        public Expression getRightOperand() {
                if (this.rightOperand ==  null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.rightOperand ==  null) {
                                        preLazyInit();
                                        this.rightOperand = new SimpleName(this.ast);
                                        postLazyInit(this.rightOperand, RIGHT_OPERAND_PROPERTY);
                                }
                        }
                }
                return this.rightOperand;
        }

        /**
         * Sets the right operand of this infix expression.
         * 
         * @param expression the right operand node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setRightOperand(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.rightOperand;
                preReplaceChild(oldChild, expression, RIGHT_OPERAND_PROPERTY);
                this.rightOperand = expression;
                postReplaceChild(oldChild, expression, RIGHT_OPERAND_PROPERTY);
        }

        /**
         * Returns the left operand of this instanceof expression.
         * 
         * @return the left operand node
         */
        public Expression getLeftOperand() {
                if (this.leftOperand ==  null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.leftOperand == null) {
                                        preLazyInit();
                                        this.leftOperand = new SimpleName(this.ast);
                                        postLazyInit(this.leftOperand, LEFT_OPERAND_PROPERTY);
                                }
                        }
                }
                return this.leftOperand;
        }

        /**
         * Sets the left operand of this instanceof expression.
         * 
         * @param expression the left operand node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setLeftOperand(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.leftOperand;
                preReplaceChild(oldChild, expression, LEFT_OPERAND_PROPERTY);
                this.leftOperand = expression;
                postReplaceChild(oldChild, expression, LEFT_OPERAND_PROPERTY);
        }

        /**
         * Returns the label of this labeled statement.
         * 
         * @return the variable name node
         */
        public SimpleName getLabel() {
                if (this.labelName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.labelName == null) {
                                        preLazyInit();
                                        this.labelName = new SimpleName(this.ast);
                                        postLazyInit(this.labelName, LABEL_PROPERTY);
                                }
                        }
                }
                return this.labelName;
        }

        /**
         * Sets the label of this labeled statement.
         * 
         * @param label the new label
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setLabel(SimpleName label) {
                if (label == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.labelName;
                preReplaceChild(oldChild, label, LABEL_PROPERTY);
                this.labelName = label;
                postReplaceChild(oldChild, label, LABEL_PROPERTY);
        }

        /**
         * Returns the name of the referenced member.
         * 
         * @return the member name node
         */
        public SimpleName getName() {
                if (this.memberName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.memberName == null) {
                                        preLazyInit();
                                        this.memberName = new SimpleName(this.ast);
                                        postLazyInit(this.memberName, NAME_PROPERTY);
                                }
                        }
                }
                return this.memberName;
        }

        /**
         * Sets the name of the referenced member to the given name.
         * 
         * @param name the new member name node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the name is <code>null</code></li>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(SimpleName name) {
                if (name == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.memberName;
                preReplaceChild(oldChild, name, NAME_PROPERTY);
                this.memberName = name;
                postReplaceChild(oldChild, name, NAME_PROPERTY);
        }

        /**
         * Returns the value expression.
         * 
         * @return the value expression
         */
        public Expression getValue() {
                if (this.value == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.value == null) {
                                        preLazyInit();
                                        this.value = new SimpleName(this.ast);
                                        postLazyInit(this.value, VALUE_PROPERTY);
                                }
                        }
                }
                return this.value;
        }

        /**
         * Sets the value of this pair.
         * 
         * @param value the new value
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setValue(Expression value) {
                if (value == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.value;
                preReplaceChild(oldChild, value, VALUE_PROPERTY);
                this.value = value;
                postReplaceChild(oldChild, value, VALUE_PROPERTY);
        }

        /**
         * Returns the name of the method declared in this method declaration.
         * For a constructor declaration, this should be the same as the name 
         * of the class.
         * 
         * @return the method name node
         */
        public SimpleName getName() {
                if (this.methodName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.methodName == null) {
                                        preLazyInit();
                                        this.methodName = new SimpleName(this.ast);
                                        postLazyInit(this.methodName, NAME_PROPERTY);
                                }
                        }
                }
                return this.methodName;
        }

        /**
         * Sets the name of the method declared in this method declaration to the
         * given name. For a constructor declaration, this should be the same as 
         * the name of the class.
         * 
         * @param methodName the new method name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(SimpleName methodName) {
                if (methodName == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.methodName;
                preReplaceChild(oldChild, methodName, NAME_PROPERTY);
                this.methodName = methodName;
                postReplaceChild(oldChild, methodName, NAME_PROPERTY);
        }

        /**
         * Returns the name of the method invoked in this expression.
         * 
         * @return the method name node
         */
        public SimpleName getName() {
                if (this.methodName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.methodName == null) {
                                        preLazyInit();
                                        this.methodName = new SimpleName(this.ast);
                                        postLazyInit(this.methodName, NAME_PROPERTY);
                                }
                        }
                }
                return this.methodName;
        }

        /**
         * Sets the name of the method invoked in this expression to the
         * given name.
         * 
         * @param name the new method name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(SimpleName name) {
                if (name == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.methodName;
                preReplaceChild(oldChild, name, NAME_PROPERTY);
                this.methodName = name;
                postReplaceChild(oldChild, name, NAME_PROPERTY);
        }

        /**
         * Returns the name of the referenced method or constructor.
         * 
         * @return the method or constructor name node
         */
        public SimpleName getName() {
                if (this.methodName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.methodName == null) {
                                        preLazyInit();
                                        this.methodName = new SimpleName(this.ast);
                                        postLazyInit(this.methodName, NAME_PROPERTY);
                                }
                        }
                }
                return this.methodName;
        }

        /**
         * Sets the name of the referenced method or constructor to the
         * given name.
         * 
         * @param name the new method or constructor name node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the name is <code>null</code></li>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(SimpleName name) {
                if (name == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.methodName;
                preReplaceChild(oldChild, name, NAME_PROPERTY);
                this.methodName = name;
                postReplaceChild(oldChild, name, NAME_PROPERTY);
        }

        /**
         * Returns the package name of this package declaration.
         * 
         * @return the package name node
         */
        public Name getName() {
                if (this.packageName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.packageName == null) {
                                        preLazyInit();
                                        this.packageName = new SimpleName(this.ast);
                                        postLazyInit(this.packageName, NAME_PROPERTY);
                                }
                        }
                }
                return this.packageName;
        }

        /**
         * Sets the package name of this package declaration to the given name.
         * 
         * @param name the new package name
         * @exception IllegalArgumentException if`:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(Name name) {
                if (name == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.packageName;
                preReplaceChild(oldChild, name, NAME_PROPERTY);
                this.packageName = name;
                postReplaceChild(oldChild, name, NAME_PROPERTY);
        }

        /**
         * Returns the expression of this parenthesized expression.
         * 
         * @return the expression node
         */
        public Expression getExpression() {
                if (this.expression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.expression == null) {
                                        preLazyInit();
                                        this.expression = new SimpleName(this.ast);
                                        postLazyInit(this.expression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.expression;
        }

        /**
         * Sets the expression of this parenthesized expression.
         * 
         * @param expression the new expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.expression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.expression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

        /**
         * Returns the operand of this postfix expression.
         * 
         * @return the operand expression node
         */
        public Expression getOperand() {
                if (this.operand ==  null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.operand == null) {
                                        preLazyInit();
                                        this.operand = new SimpleName(this.ast);
                                        postLazyInit(this.operand, OPERAND_PROPERTY);
                                }
                        }
                }
                return this.operand;
        }

        /**
         * Sets the operand of this postfix expression.
         * 
         * @param expression the operand expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setOperand(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.operand;
                preReplaceChild(oldChild, expression, OPERAND_PROPERTY);
                this.operand = expression;
                postReplaceChild(oldChild, expression, OPERAND_PROPERTY);
        }

        /**
         * Returns the operand of this prefix expression.
         * 
         * @return the operand expression node
         */
        public Expression getOperand() {
                if (this.operand ==  null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.operand == null) {
                                        preLazyInit();
                                        this.operand = new SimpleName(this.ast);
                                        postLazyInit(this.operand, OPERAND_PROPERTY);
                                }
                        }
                }
                return this.operand;
        }

        /**
         * Sets the operand of this prefix expression.
         * 
         * @param expression the operand expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setOperand(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.operand;
                preReplaceChild(oldChild, expression, OPERAND_PROPERTY);
                this.operand = expression;
                postReplaceChild(oldChild, expression, OPERAND_PROPERTY);
        }

        /**
         * Returns the qualifier part of this qualified name.
         * 
         * @return the qualifier part of this qualified name
         */
        public Name getQualifier() {
                if (this.qualifier == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.qualifier == null) {
                                        preLazyInit();
                                        this.qualifier = new SimpleName(this.ast);
                                        postLazyInit(this.qualifier, QUALIFIER_PROPERTY);
                                }
                        }
                }
                return this.qualifier;
        }

        /**
         * Sets the qualifier of this qualified name to the given name.
         * 
         * @param qualifier the qualifier of this qualified name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setQualifier(Name qualifier) {
                if (qualifier == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.qualifier;
                preReplaceChild(oldChild, qualifier, QUALIFIER_PROPERTY);
                this.qualifier = qualifier;
                postReplaceChild(oldChild, qualifier, QUALIFIER_PROPERTY);
        }

        /**
         * Returns the name part of this qualified name.
         * 
         * @return the name being qualified 
         */
        public SimpleName getName() {
                if (this.name == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.name == null) {
                                        preLazyInit();
                                        this.name = new SimpleName(this.ast);
                                        postLazyInit(this.name, NAME_PROPERTY);
                                }
                        }
                }
                return this.name;
        }

        /**
         * Sets the name part of this qualified name to the given simple name.
         * 
         * @param name the identifier of this qualified name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(SimpleName name) {
                if (name == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.name;
                preReplaceChild(oldChild, name, NAME_PROPERTY);
                this.name = name;
                postReplaceChild(oldChild, name, NAME_PROPERTY);
        }

        /**
         * Returns the name part of this qualified type.
         * 
         * @return the name being qualified 
         */
        public SimpleName getName() {
                if (this.name == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.name == null) {
                                        preLazyInit();
                                        this.name = new SimpleName(this.ast);
                                        postLazyInit(this.name, NAME_PROPERTY);
                                }
                        }
                }
                return this.name;
        }

        /**
         * Sets the name part of this qualified type to the given simple name.
         * 
         * @param name the identifier of this qualified name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(SimpleName name) {
                if (name == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.name;
                preReplaceChild(oldChild, name, NAME_PROPERTY);
                this.name = name;
                postReplaceChild(oldChild, name, NAME_PROPERTY);
        }

        /**
         * Returns the name of this simple type.
         * 
         * @return the name of this simple type
         */
        public Name getName() {
                if (this.typeName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.typeName == null) {
                                        preLazyInit();
                                        this.typeName = new SimpleName(this.ast);
                                        postLazyInit(this.typeName, NAME_PROPERTY);
                                }
                        }
                }
                return this.typeName;
        }

        /**
         * Sets the name of this simple type to the given name.
         * 
         * @param typeName the new name of this simple type
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(Name typeName) {
                if (typeName == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.typeName;
                preReplaceChild(oldChild, typeName, NAME_PROPERTY);
                this.typeName = typeName;
                postReplaceChild(oldChild, typeName, NAME_PROPERTY);
        }

        /**
         * Returns the value of this annotation.
         * 
         * @return the value node
         */
        public Expression getValue() {
                if (this.value == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.value == null) {
                                        preLazyInit();
                                        this.value = new SimpleName(this.ast);
                                        postLazyInit(this.value, VALUE_PROPERTY);
                                }
                        }
                }
                return this.value;
        }

        /**
         * Sets the value of this annotation.
         * 
         * @param value the new value
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setValue(Expression value) {
                if (value == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.value;
                preReplaceChild(oldChild, value, VALUE_PROPERTY);
                this.value = value;
                postReplaceChild(oldChild, value, VALUE_PROPERTY);
        }

        /* (omit javadoc for this method)
         * Method declared on VariableDeclaration.
         */
        public SimpleName getName() {
                if (this.variableName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.variableName == null) {
                                        preLazyInit();
                                        this.variableName = new SimpleName(this.ast);
                                        postLazyInit(this.variableName, NAME_PROPERTY);
                                }
                        }
                }
                return this.variableName;
        }

        /* (omit javadoc for this method)
         * Method declared on VariableDeclaration.
         */
        public void setName(SimpleName variableName) {
                if (variableName == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.variableName;
                preReplaceChild(oldChild, variableName, NAME_PROPERTY);
                this.variableName = variableName;
                postReplaceChild(oldChild, variableName, NAME_PROPERTY);
        }

        /**
         * Returns the name of the method invoked in this expression.
         * 
         * @return the method name node
         */
        public SimpleName getName() {
                if (this.methodName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.methodName == null) {
                                        preLazyInit();
                                        this.methodName = new SimpleName(this.ast);
                                        postLazyInit(this.methodName, NAME_PROPERTY);
                                }
                        }
                }
                return this.methodName;
        }

        /**
         * Sets the name of the method invoked in this expression to the
         * given name.
         * 
         * @param name the new method name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
        public void setName(SimpleName name) {
                if (name == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.methodName;
                preReplaceChild(oldChild, name, NAME_PROPERTY);
                this.methodName = name;
                postReplaceChild(oldChild, name, NAME_PROPERTY);
        }

        /**
         * Returns the expression of this switch statement.
         * 
         * @return the expression node
         */
        public Expression getExpression() {
                if (this.expression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.expression == null) {
                                        preLazyInit();
                                        this.expression = new SimpleName(this.ast);
                                        postLazyInit(this.expression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.expression;
        }

        /**
         * Sets the expression of this switch statement.
         * 
         * @param expression the new expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.expression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.expression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

        /**
         * Returns the expression of this synchronized statement.
         * 
         * @return the expression node
         */
        public Expression getExpression() {
                if (this.expression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.expression == null) {
                                        preLazyInit();
                                        this.expression = new SimpleName(this.ast);
                                        postLazyInit(this.expression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.expression;
        }

        /**
         * Sets the expression of this synchronized statement.
         * 
         * @param expression the expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.expression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.expression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

        /**
         * Returns the expression of this throw statement.
         * 
         * @return the expression node
         */
        public Expression getExpression() {
                if (this.expression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.expression == null) {
                                        preLazyInit();
                                        this.expression = new SimpleName(this.ast);
                                        postLazyInit(this.expression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.expression;
        }

        /**
         * Sets the expression of this throw statement.
         * 
         * @param expression the new expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.expression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.expression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

        /* (omit javadoc for this method)
         * Method declared on VariableDeclaration.
         */
        public SimpleName getName() {
                if (this.variableName == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.variableName == null) {
                                        preLazyInit();
                                        this.variableName = new SimpleName(this.ast);
                                        postLazyInit(this.variableName, NAME_PROPERTY);
                                }
                        }
                }
                return this.variableName;
        }

        /* (omit javadoc for this method)
         * Method declared on VariableDeclaration.
         */
        public void setName(SimpleName variableName) {
                if (variableName == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.variableName;
                preReplaceChild(oldChild, variableName, NAME_PROPERTY);
                this.variableName = variableName;
                postReplaceChild(oldChild, variableName, NAME_PROPERTY);
        }

        /**
         * Returns the expression of this while statement.
         * 
         * @return the expression node
         */
        public Expression getExpression() {
                if (this.expression == null) {
                        // lazy init must be thread-safe for readers
                        synchronized (this ) {
                                if (this.expression == null) {
                                        preLazyInit();
                                        this.expression = new SimpleName(this.ast);
                                        postLazyInit(this.expression, EXPRESSION_PROPERTY);
                                }
                        }
                }
                return this.expression;
        }

        /**
         * Sets the expression of this while statement.
         * 
         * @param expression the expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
        public void setExpression(Expression expression) {
                if (expression == null) {
                        throw new IllegalArgumentException();
                }
                ASTNode oldChild = this.expression;
                preReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
                this.expression = expression;
                postReplaceChild(oldChild, expression, EXPRESSION_PROPERTY);
        }

/**
         * Returns the expression of this while statement.
         * 
         * @return the expression node
         */
/* (omit javadoc for this method)
         * Method declared on VariableDeclaration.
         */
/**
         * Returns the name of the method invoked in this expression.
         * 
         * @return the method name node
         */
/**
         * Returns the left operand of this instanceof expression.
         * 
         * @return the left operand node
         */
/**
         * Returns the value of this annotation.
         * 
         * @return the value node
         */
/**
         * Returns the name part of this qualified type.
         * 
         * @return the name being qualified 
         */
/**
         * Returns the operand of this prefix expression.
         * 
         * @return the operand expression node
         */
/**
         * Returns the name of the referenced member.
         * 
         * @return the member name node
         */
/**
         * Returns the name of the method declared in this method declaration.
         * For a constructor declaration, this should be the same as the name 
         * of the class.
         * 
         * @return the method name node
         */
/**
         * Returns the name of this simple type.
         * 
         * @return the name of this simple type
         */
/**
         * Returns the qualifier part of this qualified name.
         * 
         * @return the qualifier part of this qualified name
         */
/**
         * Returns the package name of this package declaration.
         * 
         * @return the package name node
         */
/**
         * Returns the label of this labeled statement.
         * 
         * @return the variable name node
         */
/**
         * Returns the right operand of this infix expression.
         * 
         * @return the right operand node
         */
/**
         * Returns the name of the constant declared in this enum declaration.
         * 
         * @return the constant name node
         */
/**
         * Returns the condition of this conditional expression.
         * 
         * @return the condition node
         */
/**
         * Returns the "then" part of this conditional expression.
         * 
         * @return the "then" expression node
         */
/**
         * Returns the "else" part of this conditional expression.
         * 
         * @return the "else" expression node
         */
/**
         * Returns the left hand side of this assignment expression.
         * 
         * @return the left hand side node
         */
/**
         * Returns the right hand side of this assignment expression.
         * 
         * @return the right hand side node
         */
/**
         * Returns the array expression of this array access expression.
         * 
         * @return the array expression node
         */
/**
         * Returns the index expression of this array access expression.
         * 
         * @return the index expression node
         */
/**
         * Returns the name of the field accessed in this field access expression.
         * 
         * @return the field name
         */
/**
         * Returns the name of the annotation type member declared in this declaration.
         * 
         * @return the member name node
         */
/**
         * Returns the expression of this cast expression.
         * 
         * @return the expression node
         */
/**
         * Returns the expression of this throw statement.
         * 
         * @return the expression node
         */
/**
         * Returns the expression of this do statement.
         * 
         * @return the expression node
         */
/**
         * Returns the expression of this parenthesized expression.
         * 
         * @return the expression node
         */
/**
         * Returns the expression of this enhanced for statement.
         * 
         * @return the expression node
         */
/**
         * Returns the name of the referenced method or constructor.
         * 
         * @return the method or constructor name node
         */
/**
         * Returns the expression of this field access expression.
         * 
         * @return the expression node
         */
/**
         * Returns the operand of this postfix expression.
         * 
         * @return the operand expression node
         */
/**
         * Returns the value expression.
         * 
         * @return the value expression
         */
/**
         * Returns the name part of this qualified name.
         * 
         * @return the name being qualified 
         */
/**
         * Returns the left operand of this infix expression.
         * 
         * @return the left operand node
         */
/**
         * Returns the expression of this if statement.
         * 
         * @return the expression node
         */
/**
         * Returns the expression of this synchronized statement.
         * 
         * @return the expression node
         */
/**
         * Returns the expression of this switch statement.
         * 
         * @return the expression node
         */
public [[#variable97b8d480]]  [[#variable97b8d420]]() {
  if (this. [[#variable97b8d360]]== null) {
    // lazy init must be thread-safe for readers
    synchronized (this ) {
      if (this. [[#variable97b8d360]]== null) {
        preLazyInit();
        this. [[#variable97b8d360]]= new SimpleName(this.ast);
        postLazyInit(this. [[#variable97b8d360]],  [[#variable97b8d300]]);
      }
    }
  }
  return this. [[#variable97b8d360]];
}

/**
         * Sets the expression of this while statement.
         * 
         * @param expression the expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/* (omit javadoc for this method)
         * Method declared on VariableDeclaration.
         */
/**
         * Sets the name of the method invoked in this expression to the
         * given name.
         * 
         * @param name the new method name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the left operand of this instanceof expression.
         * 
         * @param expression the left operand node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the value of this annotation.
         * 
         * @param value the new value
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the name part of this qualified type to the given simple name.
         * 
         * @param name the identifier of this qualified name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the operand of this prefix expression.
         * 
         * @param expression the operand expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the name of the referenced member to the given name.
         * 
         * @param name the new member name node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the name is <code>null</code></li>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the name of the method declared in this method declaration to the
         * given name. For a constructor declaration, this should be the same as 
         * the name of the class.
         * 
         * @param methodName the new method name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the name of this simple type to the given name.
         * 
         * @param typeName the new name of this simple type
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the qualifier of this qualified name to the given name.
         * 
         * @param qualifier the qualifier of this qualified name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the package name of this package declaration to the given name.
         * 
         * @param name the new package name
         * @exception IllegalArgumentException if`:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the label of this labeled statement.
         * 
         * @param label the new label
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the right operand of this infix expression.
         * 
         * @param expression the right operand node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the name of the constant declared in this enum declaration to the
         * given name.
         * 
         * @param constantName the new constant name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the condition of this conditional expression.
         * 
         * @param expression the condition node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the "then" part of this conditional expression.
         * 
         * @param expression the "then" expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the "else" part of this conditional expression.
         * 
         * @param expression the "else" expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the left hand side of this assignment expression.
         * 
         * @param expression the left hand side node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the right hand side of this assignment expression.
         * 
         * @param expression the right hand side node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the array expression of this array access expression.
         * 
         * @param expression the array expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the index expression of this array access expression.
         * 
         * @param expression the index expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the name of the field accessed in this field access expression.
         * 
         * @param fieldName the field name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the name of the annotation type member declared in this declaration to the
         * given name.
         * 
         * @param memberName the new member name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the expression of this cast expression.
         * 
         * @param expression the new expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the expression of this throw statement.
         * 
         * @param expression the new expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the expression of this do statement.
         * 
         * @param expression the expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the expression of this parenthesized expression.
         * 
         * @param expression the new expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the expression of this enhanced for statement.
         * 
         * @param expression the new expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the name of the referenced method or constructor to the
         * given name.
         * 
         * @param name the new method or constructor name node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the name is <code>null</code></li>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the expression of this field access expression.
         * 
         * @param expression the new expression
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the operand of this postfix expression.
         * 
         * @param expression the operand expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the value of this pair.
         * 
         * @param value the new value
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the name part of this qualified name to the given simple name.
         * 
         * @param name the identifier of this qualified name
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * </ul>
         */
/**
         * Sets the left operand of this infix expression.
         * 
         * @param expression the left operand node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the condition of this if statement.
         * 
         * @param expression the expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the expression of this synchronized statement.
         * 
         * @param expression the expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
/**
         * Sets the expression of this switch statement.
         * 
         * @param expression the new expression node
         * @exception IllegalArgumentException if:
         * <ul>
         * <li>the node belongs to a different AST</li>
         * <li>the node already has a parent</li>
         * <li>a cycle in would be created</li>
         * </ul>
         */
public void [[#variable97b8c620]]( [[#variable97b8d480]]  [[#variable97b8d240]]) {
  if ( [[#variable97b8d240]]== null) {
    throw new IllegalArgumentException();
  }
  // an Assignment may occur inside a Expression - must check cycles
  // an ArrayAccess may occur inside an Expression
  // must check cycles
  ASTNode oldChild = this. [[#variable97b8d360]];
  preReplaceChild(oldChild,  [[#variable97b8d240]],  [[#variable97b8d300]]);
  this. [[#variable97b8d360]]= [[#variable97b8d240]];
  postReplaceChild(oldChild,  [[#variable97b8d240]],  [[#variable97b8d300]]);
}
 

Expression 

SimpleName 

SimpleName 

Expression 

Expression 

SimpleName 

Expression 

SimpleName 

SimpleName 

Name 

Name 

Name 

SimpleName 

Expression 

SimpleName 

Expression 

Expression 

Expression 

Expression 

Expression 

Expression 

Expression 

SimpleName 

SimpleName 

Expression 

Expression 

Expression 

Expression 

Expression 

SimpleName 

Expression 

Expression 

Expression 

SimpleName 

Expression 

Expression 

SimpleName 

Expression 

SimpleName 

Expression 

getExpression 

getName 

getName 

getLeftOperand 

getValue 

getName 

getOperand 

getName 

getName 

getName 

getQualifier 

getName 

getLabel 

getRightOperand 

getName 

getExpression 

getThenExpression 

getElseExpression 

getLeftHandSide 

getRightHandSide 

getArray 

getIndex 

getName 

getName 

getExpression 

getExpression 

getExpression 

getExpression 

getExpression 

getName 

getExpression 

getOperand 

getValue 

getName 

getLeftOperand 

getExpression 

getName 

getExpression 

getName 

getExpression 

expression 

variableName 

methodName 

leftOperand 

value 

name 

operand 

memberName 

methodName 

typeName 

qualifier 

packageName 

labelName 

rightOperand 

constantName 

conditionExpression 

thenExpression 

elseExpression 

leftHandSide 

rightHandSide 

arrayExpression 

indexExpression 

fieldName 

memberName 

expression 

expression 

expression 

expression 

expression 

methodName 

expression 

operand 

value 

name 

leftOperand 

expression 

methodName 

expression 

variableName 

expression 

EXPRESSION_PROPERTY 

NAME_PROPERTY 

NAME_PROPERTY 

LEFT_OPERAND_PROPERTY 

VALUE_PROPERTY 

NAME_PROPERTY 

OPERAND_PROPERTY 

NAME_PROPERTY 

NAME_PROPERTY 

NAME_PROPERTY 

QUALIFIER_PROPERTY 

NAME_PROPERTY 

LABEL_PROPERTY 

RIGHT_OPERAND_PROPERTY 

NAME_PROPERTY 

EXPRESSION_PROPERTY 

THEN_EXPRESSION_PROPERTY 

ELSE_EXPRESSION_PROPERTY 

LEFT_HAND_SIDE_PROPERTY 

RIGHT_HAND_SIDE_PROPERTY 

ARRAY_PROPERTY 

INDEX_PROPERTY 

NAME_PROPERTY 

NAME_PROPERTY 

EXPRESSION_PROPERTY 

EXPRESSION_PROPERTY 

EXPRESSION_PROPERTY 

EXPRESSION_PROPERTY 

EXPRESSION_PROPERTY 

NAME_PROPERTY 

EXPRESSION_PROPERTY 

OPERAND_PROPERTY 

VALUE_PROPERTY 

NAME_PROPERTY 

LEFT_OPERAND_PROPERTY 

EXPRESSION_PROPERTY 

NAME_PROPERTY 

EXPRESSION_PROPERTY 

NAME_PROPERTY 

EXPRESSION_PROPERTY 

setExpression 

setName 

setName 

setLeftOperand 

setValue 

setName 

setOperand 

setName 

setName 

setName 

setQualifier 

setName 

setLabel 

setRightOperand 

setName 

setExpression 

setThenExpression 

setElseExpression 

setLeftHandSide 

setRightHandSide 

setArray 

setIndex 

setName 

setName 

setExpression 

setExpression 

setExpression 

setExpression 

setExpression 

setName 

setExpression 

setOperand 

setValue 

setName 

setLeftOperand 

setExpression 

setName 

setExpression 

setName 

setExpression 

expression 

variableName 

name 

expression 

value 

name 

expression 

name 

methodName 

typeName 

qualifier 

name 

label 

expression 

constantName 

expression 

expression 

expression 

expression 

expression 

expression 

expression 

fieldName 

memberName 

expression 

expression 

expression 

expression 

expression 

name 

expression 

expression 

value 

name 

expression 

expression 

name 

expression 

variableName 

expression