CloneSet6


Previous CloneSetNext CloneSetBack to Main Report
Clone
Mass
Clones in
CloneSet
Parameter
Count
Clone
Similarity
Syntax Category
[Sequence Length]
334060.951class_body_declarations[2]
Clone AbstractionParameter Bindings
Clone Instance
(Click to see clone)
Line CountSource Line
Source File
133275
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AnnotationTypeMemberDeclaration.java
235174
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ArrayAccess.java
335216
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ArrayAccess.java
434345
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Assignment.java
534386
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Assignment.java
633211
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CastExpression.java
733200
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ConditionalExpression.java
833240
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ConditionalExpression.java
933280
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ConditionalExpression.java
1033174
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DoStatement.java
1133236
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/EnhancedForStatement.java
1233269
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/EnumConstantDeclaration.java
1333204
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/FieldAccess.java
1432244
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/FieldAccess.java
1533200
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IfStatement.java
1633405
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/InfixExpression.java
1733445
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/InfixExpression.java
1833170
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/InstanceofExpression.java
1932176
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/LabeledStatement.java
2033204
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MemberRef.java
2133228
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MemberValuePair.java
2234553
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodDeclaration.java
2333301
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodInvocation.java
2434236
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodRef.java
2532294
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PackageDeclaration.java
2633148
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ParenthesizedExpression.java
2733278
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PostfixExpression.java
2833295
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PrefixExpression.java
2933180
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/QualifiedName.java
3032220
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/QualifiedName.java
3132232
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/QualifiedType.java
3232146
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SimpleType.java
3333174
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SingleMemberAnnotation.java
3425463
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SingleVariableDeclaration.java
3533300
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SuperMethodInvocation.java
3633186
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SwitchStatement.java
3733174
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SynchronizedStatement.java
3833150
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ThrowStatement.java
3925232
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/VariableDeclarationFragment.java
4033175
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/WhileStatement.java
Clone Instance
1
Line Count
33
Source Line
275
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AnnotationTypeMemberDeclaration.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);
        }


Clone Instance
2
Line Count
35
Source Line
174
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ArrayAccess.java

        /**
         * 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);
        }


Clone Instance
3
Line Count
35
Source Line
216
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ArrayAccess.java

        /**
         * 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);
        }


Clone Instance
4
Line Count
34
Source Line
345
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Assignment.java

        /**
         * 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);
        }


Clone Instance
5
Line Count
34
Source Line
386
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Assignment.java

        /**
         * 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);
        }


Clone Instance
6
Line Count
33
Source Line
211
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CastExpression.java

        /**
         * 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);
        }


Clone Instance
7
Line Count
33
Source Line
200
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ConditionalExpression.java

        /**
         * 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);
        }


Clone Instance
8
Line Count
33
Source Line
240
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ConditionalExpression.java

        /**
         * 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);
        }


Clone Instance
9
Line Count
33
Source Line
280
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ConditionalExpression.java

        /**
         * 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);
        }


Clone Instance
10
Line Count
33
Source Line
174
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DoStatement.java

        /**
         * 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);
        }


Clone Instance
11
Line Count
33
Source Line
236
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/EnhancedForStatement.java

        /**
         * 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);
        }


Clone Instance
12
Line Count
33
Source Line
269
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/EnumConstantDeclaration.java

        /**
         * 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);
        }


Clone Instance
13
Line Count
33
Source Line
204
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/FieldAccess.java

        /**
         * 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);
        }


Clone Instance
14
Line Count
32
Source Line
244
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/FieldAccess.java

        /**
         * 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);
        }


Clone Instance
15
Line Count
33
Source Line
200
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IfStatement.java

        /**
         * 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);
        }


Clone Instance
16
Line Count
33
Source Line
405
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/InfixExpression.java

        /**
         * 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);
        }


Clone Instance
17
Line Count
33
Source Line
445
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/InfixExpression.java

        /**
         * 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);
        }


Clone Instance
18
Line Count
33
Source Line
170
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/InstanceofExpression.java

        /**
         * 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);
        }


Clone Instance
19
Line Count
32
Source Line
176
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/LabeledStatement.java

        /**
         * 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);
        }


Clone Instance
20
Line Count
33
Source Line
204
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MemberRef.java

        /**
         * 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);
        }


Clone Instance
21
Line Count
33
Source Line
228
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MemberValuePair.java

        /**
         * 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);
        }


Clone Instance
22
Line Count
34
Source Line
553
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodDeclaration.java

        /**
         * 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);
        }


Clone Instance
23
Line Count
33
Source Line
301
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodInvocation.java

        /**
         * 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);
        }


Clone Instance
24
Line Count
34
Source Line
236
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodRef.java

        /**
         * 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);
        }


Clone Instance
25
Line Count
32
Source Line
294
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PackageDeclaration.java

        /**
         * 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);
        }


Clone Instance
26
Line Count
33
Source Line
148
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ParenthesizedExpression.java

        /**
         * 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);
        }


Clone Instance
27
Line Count
33
Source Line
278
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PostfixExpression.java

        /**
         * 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);
        }


Clone Instance
28
Line Count
33
Source Line
295
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PrefixExpression.java

        /**
         * 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);
        }


Clone Instance
29
Line Count
33
Source Line
180
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/QualifiedName.java

        /**
         * 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);
        }


Clone Instance
30
Line Count
32
Source Line
220
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/QualifiedName.java

        /**
         * 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);
        }


Clone Instance
31
Line Count
32
Source Line
232
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/QualifiedType.java

        /**
         * 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);
        }


Clone Instance
32
Line Count
32
Source Line
146
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SimpleType.java

        /**
         * 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);
        }


Clone Instance
33
Line Count
33
Source Line
174
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SingleMemberAnnotation.java

        /**
         * 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);
        }


Clone Instance
34
Line Count
25
Source Line
463
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SingleVariableDeclaration.java

        /* (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);
        }


Clone Instance
35
Line Count
33
Source Line
300
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SuperMethodInvocation.java

        /**
         * 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);
        }


Clone Instance
36
Line Count
33
Source Line
186
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SwitchStatement.java

        /**
         * 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);
        }


Clone Instance
37
Line Count
33
Source Line
174
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SynchronizedStatement.java

        /**
         * 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);
        }


Clone Instance
38
Line Count
33
Source Line
150
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ThrowStatement.java

        /**
         * 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);
        }


Clone Instance
39
Line Count
25
Source Line
232
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/VariableDeclarationFragment.java

        /* (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);
        }


Clone Instance
40
Line Count
33
Source Line
175
Source File
plugins/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/WhileStatement.java

        /**
         * 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);
        }


Clone AbstractionParameter Count: 6Parameter Bindings

/**
         * 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]]);
}
 

CloneAbstraction
Parameter Bindings
Parameter
Index
Clone
Instance
Parameter
Name
Value
11[[#97b8d480]]
Expression 
12[[#97b8d480]]
SimpleName 
13[[#97b8d480]]
SimpleName 
14[[#97b8d480]]
Expression 
15[[#97b8d480]]
Expression 
16[[#97b8d480]]
SimpleName 
17[[#97b8d480]]
Expression 
18[[#97b8d480]]
SimpleName 
19[[#97b8d480]]
SimpleName 
110[[#97b8d480]]
Name 
111[[#97b8d480]]
Name 
112[[#97b8d480]]
Name 
113[[#97b8d480]]
SimpleName 
114[[#97b8d480]]
Expression 
115[[#97b8d480]]
SimpleName 
116[[#97b8d480]]
Expression 
117[[#97b8d480]]
Expression 
118[[#97b8d480]]
Expression 
119[[#97b8d480]]
Expression 
120[[#97b8d480]]
Expression 
121[[#97b8d480]]
Expression 
122[[#97b8d480]]
Expression 
123[[#97b8d480]]
SimpleName 
124[[#97b8d480]]
SimpleName 
125[[#97b8d480]]
Expression 
126[[#97b8d480]]
Expression 
127[[#97b8d480]]
Expression 
128[[#97b8d480]]
Expression 
129[[#97b8d480]]
Expression 
130[[#97b8d480]]
SimpleName 
131[[#97b8d480]]
Expression 
132[[#97b8d480]]
Expression 
133[[#97b8d480]]
Expression 
134[[#97b8d480]]
SimpleName 
135[[#97b8d480]]
Expression 
136[[#97b8d480]]
Expression 
137[[#97b8d480]]
SimpleName 
138[[#97b8d480]]
Expression 
139[[#97b8d480]]
SimpleName 
140[[#97b8d480]]
Expression 
21[[#97b8d420]]
getExpression 
22[[#97b8d420]]
getName 
23[[#97b8d420]]
getName 
24[[#97b8d420]]
getLeftOperand 
25[[#97b8d420]]
getValue 
26[[#97b8d420]]
getName 
27[[#97b8d420]]
getOperand 
28[[#97b8d420]]
getName 
29[[#97b8d420]]
getName 
210[[#97b8d420]]
getName 
211[[#97b8d420]]
getQualifier 
212[[#97b8d420]]
getName 
213[[#97b8d420]]
getLabel 
214[[#97b8d420]]
getRightOperand 
215[[#97b8d420]]
getName 
216[[#97b8d420]]
getExpression 
217[[#97b8d420]]
getThenExpression 
218[[#97b8d420]]
getElseExpression 
219[[#97b8d420]]
getLeftHandSide 
220[[#97b8d420]]
getRightHandSide 
221[[#97b8d420]]
getArray 
222[[#97b8d420]]
getIndex 
223[[#97b8d420]]
getName 
224[[#97b8d420]]
getName 
225[[#97b8d420]]
getExpression 
226[[#97b8d420]]
getExpression 
227[[#97b8d420]]
getExpression 
228[[#97b8d420]]
getExpression 
229[[#97b8d420]]
getExpression 
230[[#97b8d420]]
getName 
231[[#97b8d420]]
getExpression 
232[[#97b8d420]]
getOperand 
233[[#97b8d420]]
getValue 
234[[#97b8d420]]
getName 
235[[#97b8d420]]
getLeftOperand 
236[[#97b8d420]]
getExpression 
237[[#97b8d420]]
getName 
238[[#97b8d420]]
getExpression 
239[[#97b8d420]]
getName 
240[[#97b8d420]]
getExpression 
31[[#97b8d360]]
expression 
32[[#97b8d360]]
variableName 
33[[#97b8d360]]
methodName 
34[[#97b8d360]]
leftOperand 
35[[#97b8d360]]
value 
36[[#97b8d360]]
name 
37[[#97b8d360]]
operand 
38[[#97b8d360]]
memberName 
39[[#97b8d360]]
methodName 
310[[#97b8d360]]
typeName 
311[[#97b8d360]]
qualifier 
312[[#97b8d360]]
packageName 
313[[#97b8d360]]
labelName 
314[[#97b8d360]]
rightOperand 
315[[#97b8d360]]
constantName 
316[[#97b8d360]]
conditionExpression 
317[[#97b8d360]]
thenExpression 
318[[#97b8d360]]
elseExpression 
319[[#97b8d360]]
leftHandSide 
320[[#97b8d360]]
rightHandSide 
321[[#97b8d360]]
arrayExpression 
322[[#97b8d360]]
indexExpression 
323[[#97b8d360]]
fieldName 
324[[#97b8d360]]
memberName 
325[[#97b8d360]]
expression 
326[[#97b8d360]]
expression 
327[[#97b8d360]]
expression 
328[[#97b8d360]]
expression 
329[[#97b8d360]]
expression 
330[[#97b8d360]]
methodName 
331[[#97b8d360]]
expression 
332[[#97b8d360]]
operand 
333[[#97b8d360]]
value 
334[[#97b8d360]]
name 
335[[#97b8d360]]
leftOperand 
336[[#97b8d360]]
expression 
337[[#97b8d360]]
methodName 
338[[#97b8d360]]
expression 
339[[#97b8d360]]
variableName 
340[[#97b8d360]]
expression 
41[[#97b8d300]]
EXPRESSION_PROPERTY 
42[[#97b8d300]]
NAME_PROPERTY 
43[[#97b8d300]]
NAME_PROPERTY 
44[[#97b8d300]]
LEFT_OPERAND_PROPERTY 
45[[#97b8d300]]
VALUE_PROPERTY 
46[[#97b8d300]]
NAME_PROPERTY 
47[[#97b8d300]]
OPERAND_PROPERTY 
48[[#97b8d300]]
NAME_PROPERTY 
49[[#97b8d300]]
NAME_PROPERTY 
410[[#97b8d300]]
NAME_PROPERTY 
411[[#97b8d300]]
QUALIFIER_PROPERTY 
412[[#97b8d300]]
NAME_PROPERTY 
413[[#97b8d300]]
LABEL_PROPERTY 
414[[#97b8d300]]
RIGHT_OPERAND_PROPERTY 
415[[#97b8d300]]
NAME_PROPERTY 
416[[#97b8d300]]
EXPRESSION_PROPERTY 
417[[#97b8d300]]
THEN_EXPRESSION_PROPERTY 
418[[#97b8d300]]
ELSE_EXPRESSION_PROPERTY 
419[[#97b8d300]]
LEFT_HAND_SIDE_PROPERTY 
420[[#97b8d300]]
RIGHT_HAND_SIDE_PROPERTY 
421[[#97b8d300]]
ARRAY_PROPERTY 
422[[#97b8d300]]
INDEX_PROPERTY 
423[[#97b8d300]]
NAME_PROPERTY 
424[[#97b8d300]]
NAME_PROPERTY 
425[[#97b8d300]]
EXPRESSION_PROPERTY 
426[[#97b8d300]]
EXPRESSION_PROPERTY 
427[[#97b8d300]]
EXPRESSION_PROPERTY 
428[[#97b8d300]]
EXPRESSION_PROPERTY 
429[[#97b8d300]]
EXPRESSION_PROPERTY 
430[[#97b8d300]]
NAME_PROPERTY 
431[[#97b8d300]]
EXPRESSION_PROPERTY 
432[[#97b8d300]]
OPERAND_PROPERTY 
433[[#97b8d300]]
VALUE_PROPERTY 
434[[#97b8d300]]
NAME_PROPERTY 
435[[#97b8d300]]
LEFT_OPERAND_PROPERTY 
436[[#97b8d300]]
EXPRESSION_PROPERTY 
437[[#97b8d300]]
NAME_PROPERTY 
438[[#97b8d300]]
EXPRESSION_PROPERTY 
439[[#97b8d300]]
NAME_PROPERTY 
440[[#97b8d300]]
EXPRESSION_PROPERTY 
51[[#97b8c620]]
setExpression 
52[[#97b8c620]]
setName 
53[[#97b8c620]]
setName 
54[[#97b8c620]]
setLeftOperand 
55[[#97b8c620]]
setValue 
56[[#97b8c620]]
setName 
57[[#97b8c620]]
setOperand 
58[[#97b8c620]]
setName 
59[[#97b8c620]]
setName 
510[[#97b8c620]]
setName 
511[[#97b8c620]]
setQualifier 
512[[#97b8c620]]
setName 
513[[#97b8c620]]
setLabel 
514[[#97b8c620]]
setRightOperand 
515[[#97b8c620]]
setName 
516[[#97b8c620]]
setExpression 
517[[#97b8c620]]
setThenExpression 
518[[#97b8c620]]
setElseExpression 
519[[#97b8c620]]
setLeftHandSide 
520[[#97b8c620]]
setRightHandSide 
521[[#97b8c620]]
setArray 
522[[#97b8c620]]
setIndex 
523[[#97b8c620]]
setName 
524[[#97b8c620]]
setName 
525[[#97b8c620]]
setExpression 
526[[#97b8c620]]
setExpression 
527[[#97b8c620]]
setExpression 
528[[#97b8c620]]
setExpression 
529[[#97b8c620]]
setExpression 
530[[#97b8c620]]
setName 
531[[#97b8c620]]
setExpression 
532[[#97b8c620]]
setOperand 
533[[#97b8c620]]
setValue 
534[[#97b8c620]]
setName 
535[[#97b8c620]]
setLeftOperand 
536[[#97b8c620]]
setExpression 
537[[#97b8c620]]
setName 
538[[#97b8c620]]
setExpression 
539[[#97b8c620]]
setName 
540[[#97b8c620]]
setExpression 
61[[#97b8d240]]
expression 
62[[#97b8d240]]
variableName 
63[[#97b8d240]]
name 
64[[#97b8d240]]
expression 
65[[#97b8d240]]
value 
66[[#97b8d240]]
name 
67[[#97b8d240]]
expression 
68[[#97b8d240]]
name 
69[[#97b8d240]]
methodName 
610[[#97b8d240]]
typeName 
611[[#97b8d240]]
qualifier 
612[[#97b8d240]]
name 
613[[#97b8d240]]
label 
614[[#97b8d240]]
expression 
615[[#97b8d240]]
constantName 
616[[#97b8d240]]
expression 
617[[#97b8d240]]
expression 
618[[#97b8d240]]
expression 
619[[#97b8d240]]
expression 
620[[#97b8d240]]
expression 
621[[#97b8d240]]
expression 
622[[#97b8d240]]
expression 
623[[#97b8d240]]
fieldName 
624[[#97b8d240]]
memberName 
625[[#97b8d240]]
expression 
626[[#97b8d240]]
expression 
627[[#97b8d240]]
expression 
628[[#97b8d240]]
expression 
629[[#97b8d240]]
expression 
630[[#97b8d240]]
name 
631[[#97b8d240]]
expression 
632[[#97b8d240]]
expression 
633[[#97b8d240]]
value 
634[[#97b8d240]]
name 
635[[#97b8d240]]
expression 
636[[#97b8d240]]
expression 
637[[#97b8d240]]
name 
638[[#97b8d240]]
expression 
639[[#97b8d240]]
variableName 
640[[#97b8d240]]
expression