ModelFactoryImpl.java

/**
 * Copyright 2011-2015 Asakusa Framework Team.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.asakusafw.utils.java.internal.model.syntax;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import javax.annotation.Generated;

import com.asakusafw.utils.java.internal.model.util.ExpressionPriority;
import com.asakusafw.utils.java.model.syntax.*;

//CHECKSTYLE:OFF
/**
 * {@link ModelFactory}の実装。
 */
@Generated("com.asakusafw.utils.java.model.syntax.ModelFactory")
public class ModelFactoryImpl implements ModelFactory {

    @Override
    public AlternateConstructorInvocation newAlternateConstructorInvocation(
            Expression...arguments) {
        Util.notNull(arguments, "arguments"); //$NON-NLS-1$
        return this.newAlternateConstructorInvocation0(
            Collections.<Type>emptyList(),
            Arrays.asList(arguments)
        );
    }

    @Override
    public AlternateConstructorInvocation newAlternateConstructorInvocation(
            List<? extends Expression> arguments) {
        return this.newAlternateConstructorInvocation0(
            Collections.<Type>emptyList(),
            arguments
        );
    }

    @Override
    public AlternateConstructorInvocation newAlternateConstructorInvocation(
            List<? extends Type> typeArguments,
            List<? extends Expression> arguments) {
        return this.newAlternateConstructorInvocation0(
            typeArguments,
            arguments
        );
    }

    private AlternateConstructorInvocationImpl newAlternateConstructorInvocation0(
            List<? extends Type> typeArguments,
            List<? extends Expression> arguments) {
        Util.notNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        Util.notContainNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        Util.notNull(arguments, "arguments"); //$NON-NLS-1$
        Util.notContainNull(arguments, "arguments"); //$NON-NLS-1$
        AlternateConstructorInvocationImpl result = new AlternateConstructorInvocationImpl();
        result.setTypeArguments(typeArguments);
        result.setArguments(arguments);
        return result;
    }

    @Override
    public AnnotationDeclaration newAnnotationDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        return this.newAnnotationDeclaration0(
            javadoc,
            modifiers,
            name,
            bodyDeclarations
        );
    }

    private AnnotationDeclarationImpl newAnnotationDeclaration0(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        Util.notContainNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        AnnotationDeclarationImpl result = new AnnotationDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setModifiers(modifiers);
        result.setName(name);
        result.setBodyDeclarations(bodyDeclarations);
        return result;
    }

    @Override
    public AnnotationElement newAnnotationElement(
            SimpleName name,
            Expression expression) {
        return this.newAnnotationElement0(
            name,
            expression
        );
    }

    private AnnotationElementImpl newAnnotationElement0(
            SimpleName name,
            Expression expression) {
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        AnnotationElementImpl result = new AnnotationElementImpl();
        result.setName(name);
        result.setExpression(expression);
        return result;
    }

    @Override
    public AnnotationElementDeclaration newAnnotationElementDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            Type type,
            SimpleName name,
            Expression defaultExpression) {
        return this.newAnnotationElementDeclaration0(
            javadoc,
            modifiers,
            type,
            name,
            defaultExpression
        );
    }

    private AnnotationElementDeclarationImpl newAnnotationElementDeclaration0(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            Type type,
            SimpleName name,
            Expression defaultExpression) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(type, "type"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        AnnotationElementDeclarationImpl result = new AnnotationElementDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setModifiers(modifiers);
        result.setType(type);
        result.setName(name);
        result.setDefaultExpression(defaultExpression);
        return result;
    }

    @Override
    public ArrayAccessExpression newArrayAccessExpression(
            Expression array,
            Expression index) {
        return this.newArrayAccessExpression0(
            array,
            index
        );
    }

    private ArrayAccessExpressionImpl newArrayAccessExpression0(
            Expression array,
            Expression index) {
        Util.notNull(array, "array"); //$NON-NLS-1$
        Util.notNull(index, "index"); //$NON-NLS-1$
        ArrayAccessExpressionImpl result = new ArrayAccessExpressionImpl();
        result.setArray(parenthesize(array, ExpressionPriority.PRIMARY));
        result.setIndex(index);
        return result;
    }

    @Override
    public ArrayCreationExpression newArrayCreationExpression(
            ArrayType type,
            ArrayInitializer arrayInitializer) {
        return this.newArrayCreationExpression0(
            type,
            Collections.<Expression>emptyList(),
            arrayInitializer
        );
    }

    @Override
    public ArrayCreationExpression newArrayCreationExpression(
            ArrayType type,
            List<? extends Expression> dimensionExpressions,
            ArrayInitializer arrayInitializer) {
        return this.newArrayCreationExpression0(
            type,
            dimensionExpressions,
            arrayInitializer
        );
    }

    private ArrayCreationExpressionImpl newArrayCreationExpression0(
            ArrayType type,
            List<? extends Expression> dimensionExpressions,
            ArrayInitializer arrayInitializer) {
        Util.notNull(type, "type"); //$NON-NLS-1$
        Util.notNull(dimensionExpressions, "dimensionExpressions"); //$NON-NLS-1$
        Util.notContainNull(dimensionExpressions, "dimensionExpressions"); //$NON-NLS-1$
        ArrayCreationExpressionImpl result = new ArrayCreationExpressionImpl();
        result.setType(type);
        result.setDimensionExpressions(dimensionExpressions);
        result.setArrayInitializer(arrayInitializer);
        return result;
    }

    @Override
    public ArrayInitializer newArrayInitializer(Expression...elements) {
        Util.notNull(elements, "elements"); //$NON-NLS-1$
        return this.newArrayInitializer0(
            Arrays.asList(elements)
        );
    }

    @Override
    public ArrayInitializer newArrayInitializer(
            List<? extends Expression> elements) {
        return this.newArrayInitializer0(
            elements
        );
    }

    private ArrayInitializerImpl newArrayInitializer0(
            List<? extends Expression> elements) {
        Util.notNull(elements, "elements"); //$NON-NLS-1$
        Util.notContainNull(elements, "elements"); //$NON-NLS-1$
        ArrayInitializerImpl result = new ArrayInitializerImpl();
        result.setElements(elements);
        return result;
    }

    @Override
    public ArrayType newArrayType(
            Type componentType) {
        return this.newArrayType0(
            componentType
        );
    }

    private ArrayTypeImpl newArrayType0(
            Type componentType) {
        Util.notNull(componentType, "componentType"); //$NON-NLS-1$
        ArrayTypeImpl result = new ArrayTypeImpl();
        result.setComponentType(componentType);
        return result;
    }

    @Override
    public AssertStatement newAssertStatement(
            Expression expression) {
        return this.newAssertStatement0(
            expression,
            null
        );
    }

    @Override
    public AssertStatement newAssertStatement(
            Expression expression,
            Expression message) {
        return this.newAssertStatement0(
            expression,
            message
        );
    }

    private AssertStatementImpl newAssertStatement0(
            Expression expression,
            Expression message) {
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        AssertStatementImpl result = new AssertStatementImpl();
        result.setExpression(expression);
        result.setMessage(message);
        return result;
    }

    @Override
    public AssignmentExpression newAssignmentExpression(
            Expression leftHandSide,
            Expression rightHandSide) {
        return this.newAssignmentExpression0(
            leftHandSide,
            InfixOperator.ASSIGN,
            rightHandSide
        );
    }

    @Override
    public AssignmentExpression newAssignmentExpression(
            Expression leftHandSide,
            InfixOperator operator,
            Expression rightHandSide) {
        return this.newAssignmentExpression0(
            leftHandSide,
            operator,
            rightHandSide
        );
    }

    private AssignmentExpressionImpl newAssignmentExpression0(
            Expression leftHandSide,
            InfixOperator operator,
            Expression rightHandSide) {
        Util.notNull(leftHandSide, "leftHandSide"); //$NON-NLS-1$
        Util.notNull(operator, "operator"); //$NON-NLS-1$
        Util.notNull(rightHandSide, "rightHandSide"); //$NON-NLS-1$
        AssignmentExpressionImpl result = new AssignmentExpressionImpl();
        result.setLeftHandSide(parenthesize(leftHandSide, ExpressionPriority.ASSIGNMENT));
        result.setOperator(operator);
        result.setRightHandSide(parenthesizeRight(rightHandSide, ExpressionPriority.ASSIGNMENT));
        return result;
    }

    @Override
    public BasicType newBasicType(
            BasicTypeKind typeKind) {
        return this.newBasicType0(
            typeKind
        );
    }

    private BasicTypeImpl newBasicType0(
            BasicTypeKind typeKind) {
        Util.notNull(typeKind, "typeKind"); //$NON-NLS-1$
        BasicTypeImpl result = new BasicTypeImpl();
        result.setTypeKind(typeKind);
        return result;
    }

    @Override
    public Block newBlock(
            Statement... statements) {
        Util.notNull(statements, "statements"); //$NON-NLS-1$
        return this.newBlock0(
            Arrays.asList(statements)
        );
    }

    @Override
    public Block newBlock(
            List<? extends Statement> statements) {
        return this.newBlock0(
            statements
        );
    }

    private BlockImpl newBlock0(
            List<? extends Statement> statements) {
        Util.notNull(statements, "statements"); //$NON-NLS-1$
        Util.notContainNull(statements, "statements"); //$NON-NLS-1$
        BlockImpl result = new BlockImpl();
        result.setStatements(statements);
        return result;
    }

    @Override
    public BlockComment newBlockComment(
            String string) {
        return this.newBlockComment0(
            string
        );
    }

    private BlockCommentImpl newBlockComment0(
            String string) {
        Util.notNull(string, "string"); //$NON-NLS-1$
        BlockCommentImpl result = new BlockCommentImpl();
        result.setString(string);
        return result;
    }

    @Override
    public BreakStatement newBreakStatement() {
        return this.newBreakStatement0(
            null
        );
    }

    @Override
    public BreakStatement newBreakStatement(
            SimpleName target) {
        return this.newBreakStatement0(
            target
        );
    }

    private BreakStatementImpl newBreakStatement0(
            SimpleName target) {
        BreakStatementImpl result = new BreakStatementImpl();
        result.setTarget(target);
        return result;
    }

    @Override
    public CastExpression newCastExpression(
            Type type,
            Expression expression) {
        return this.newCastExpression0(
            type,
            expression
        );
    }

    private CastExpressionImpl newCastExpression0(
            Type type,
            Expression expression) {
        Util.notNull(type, "type"); //$NON-NLS-1$
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        CastExpressionImpl result = new CastExpressionImpl();
        result.setType(type);
        result.setExpression(parenthesize(expression, ExpressionPriority.CAST));
        return result;
    }

    /**
     * 新しい{@link CatchClause}を生成して返す。
     * @param parameter
     *     例外仮引数
     * @param body
     *     {@code catch}ブロック
     * @return 生成した要素
     * @throws IllegalArgumentException
     *     {@code region}に{@code null}が指定された場合
     * @throws IllegalArgumentException
     *     {@code parameter}に{@code null}が指定された場合
     * @throws IllegalArgumentException
     *     {@code body}に{@code null}が指定された場合
     */
    @Override
    public CatchClause newCatchClause(
            FormalParameterDeclaration parameter,
            Block body) {
        return this.newCatchClause0(
            parameter,
            body
        );
    }

    private CatchClauseImpl newCatchClause0(
            FormalParameterDeclaration parameter,
            Block body) {
        Util.notNull(parameter, "parameter"); //$NON-NLS-1$
        Util.notNull(body, "body"); //$NON-NLS-1$
        CatchClauseImpl result = new CatchClauseImpl();
        result.setParameter(parameter);
        result.setBody(body);
        return result;
    }

    /**
     * 新しい{@link ClassBody}を生成して返す。
     * @param bodyDeclarations
     *     メンバの一覧
     * @return 生成した要素
     * @throws IllegalArgumentException
     *     {@code region}に{@code null}が指定された場合
     * @throws IllegalArgumentException
     *     {@code bodyDeclarations}に{@code null}が指定された場合
     */
    @Override
    public ClassBody newClassBody(
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        return this.newClassBody0(
            bodyDeclarations
        );
    }

    private ClassBodyImpl newClassBody0(
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        Util.notNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        Util.notContainNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        ClassBodyImpl result = new ClassBodyImpl();
        result.setBodyDeclarations(bodyDeclarations);
        return result;
    }

    @Override
    public ClassDeclaration newClassDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            Type superClass,
            List<? extends Type> superInterfaceTypes,
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        return this.newClassDeclaration0(
            javadoc,
            modifiers,
            name,
            Collections.<TypeParameterDeclaration>emptyList(),
            superClass,
            superInterfaceTypes,
            bodyDeclarations
        );
    }

    @Override
    public ClassDeclaration newClassDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends TypeParameterDeclaration> typeParameters,
            Type superClass,
            List<? extends Type> superInterfaceTypes,
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        return this.newClassDeclaration0(
            javadoc,
            modifiers,
            name,
            typeParameters,
            superClass,
            superInterfaceTypes,
            bodyDeclarations
        );
    }

    private ClassDeclarationImpl newClassDeclaration0(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends TypeParameterDeclaration> typeParameters,
            Type superClass,
            List<? extends Type> superInterfaceTypes,
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(typeParameters, "typeParameters"); //$NON-NLS-1$
        Util.notContainNull(typeParameters, "typeParameters"); //$NON-NLS-1$
        Util.notNull(superInterfaceTypes, "superInterfaceTypes"); //$NON-NLS-1$
        Util.notContainNull(superInterfaceTypes, "superInterfaceTypes"); //$NON-NLS-1$
        Util.notNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        Util.notContainNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        ClassDeclarationImpl result = new ClassDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setModifiers(modifiers);
        result.setName(name);
        result.setTypeParameters(typeParameters);
        result.setSuperClass(superClass);
        result.setSuperInterfaceTypes(superInterfaceTypes);
        result.setBodyDeclarations(bodyDeclarations);
        return result;
    }

    @Override
    public ClassInstanceCreationExpression newClassInstanceCreationExpression(
            Type type,
            Expression...arguments) {
        Util.notNull(arguments, "arguments"); //$NON-NLS-1$
        return this.newClassInstanceCreationExpression0(
            null,
            Collections.<Type>emptyList(),
            type,
            Arrays.asList(arguments),
            null
        );
    }

    @Override
    public ClassInstanceCreationExpression newClassInstanceCreationExpression(
            Type type,
            List<? extends Expression> arguments) {
        return this.newClassInstanceCreationExpression0(
            null,
            Collections.<Type>emptyList(),
            type,
            arguments,
            null
        );
    }

    @Override
    public ClassInstanceCreationExpression newClassInstanceCreationExpression(
            Expression qualifier,
            List<? extends Type> typeArguments,
            Type type,
            List<? extends Expression> arguments,
            ClassBody body) {
        return this.newClassInstanceCreationExpression0(
            qualifier,
            typeArguments,
            type,
            arguments,
            body
        );
    }

    private ClassInstanceCreationExpressionImpl newClassInstanceCreationExpression0(
            Expression qualifier,
            List<? extends Type> typeArguments,
            Type type,
            List<? extends Expression> arguments,
            ClassBody body) {
        Util.notNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        Util.notContainNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        Util.notNull(type, "type"); //$NON-NLS-1$
        Util.notNull(arguments, "arguments"); //$NON-NLS-1$
        Util.notContainNull(arguments, "arguments"); //$NON-NLS-1$
        ClassInstanceCreationExpressionImpl result = new ClassInstanceCreationExpressionImpl();
        result.setQualifier(parenthesize(qualifier, ExpressionPriority.PRIMARY));
        result.setTypeArguments(typeArguments);
        result.setType(type);
        result.setArguments(arguments);
        result.setBody(body);
        return result;
    }

    @Override
    public ClassLiteral newClassLiteral(
            Type type) {
        return this.newClassLiteral0(
            type
        );
    }

    private ClassLiteralImpl newClassLiteral0(
            Type type) {
        Util.notNull(type, "type"); //$NON-NLS-1$
        ClassLiteralImpl result = new ClassLiteralImpl();
        result.setType(type);
        return result;
    }

    @Override
    public CompilationUnit newCompilationUnit(
            PackageDeclaration packageDeclaration,
            List<? extends ImportDeclaration> importDeclarations,
            List<? extends TypeDeclaration> typeDeclarations,
            List<? extends Comment> comments) {
        return this.newCompilationUnit0(
            packageDeclaration,
            importDeclarations,
            typeDeclarations,
            comments
        );
    }

    private CompilationUnitImpl newCompilationUnit0(
            PackageDeclaration packageDeclaration,
            List<? extends ImportDeclaration> importDeclarations,
            List<? extends TypeDeclaration> typeDeclarations,
            List<? extends Comment> comments) {
        Util.notNull(importDeclarations, "importDeclarations"); //$NON-NLS-1$
        Util.notContainNull(importDeclarations, "importDeclarations"); //$NON-NLS-1$
        Util.notNull(typeDeclarations, "typeDeclarations"); //$NON-NLS-1$
        Util.notContainNull(typeDeclarations, "typeDeclarations"); //$NON-NLS-1$
        Util.notNull(comments, "comments"); //$NON-NLS-1$
        Util.notContainNull(comments, "comments"); //$NON-NLS-1$
        CompilationUnitImpl result = new CompilationUnitImpl();
        result.setPackageDeclaration(packageDeclaration);
        result.setImportDeclarations(importDeclarations);
        result.setTypeDeclarations(typeDeclarations);
        result.setComments(comments);
        return result;
    }

    @Override
    public ConditionalExpression newConditionalExpression(
            Expression condition,
            Expression thenExpression,
            Expression elseExpression) {
        return this.newConditionalExpression0(
            condition,
            thenExpression,
            elseExpression
        );
    }

    private ConditionalExpressionImpl newConditionalExpression0(
            Expression condition,
            Expression thenExpression,
            Expression elseExpression) {
        Util.notNull(condition, "condition"); //$NON-NLS-1$
        Util.notNull(thenExpression, "thenExpression"); //$NON-NLS-1$
        Util.notNull(elseExpression, "elseExpression"); //$NON-NLS-1$
        ConditionalExpressionImpl result = new ConditionalExpressionImpl();
        result.setCondition(parenthesize(condition, ExpressionPriority.CONDITIONAL));
        result.setThenExpression(parenthesize(thenExpression, ExpressionPriority.CONDITIONAL));
        result.setElseExpression(parenthesize(elseExpression, ExpressionPriority.CONDITIONAL));
        return result;
    }

    @Override
    public ConstructorDeclaration newConstructorDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends FormalParameterDeclaration> formalParameters,
            List<? extends Statement> statements) {
        Util.notNull(statements, "statements"); //$NON-NLS-1$
        return this.newConstructorDeclaration0(
            javadoc,
            modifiers,
            Collections.<TypeParameterDeclaration>emptyList(),
            name,
            formalParameters,
            Collections.<Type>emptyList(),
            newBlock(statements)
        );
    }

    @Override
    public ConstructorDeclaration newConstructorDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            List<? extends TypeParameterDeclaration> typeParameters,
            SimpleName name,
            List<? extends FormalParameterDeclaration> formalParameters,
            List<? extends Type> exceptionTypes,
            Block body) {
        return this.newConstructorDeclaration0(
            javadoc,
            modifiers,
            typeParameters,
            name,
            formalParameters,
            exceptionTypes,
            body
        );
    }

    private ConstructorDeclarationImpl newConstructorDeclaration0(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            List<? extends TypeParameterDeclaration> typeParameters,
            SimpleName name,
            List<? extends FormalParameterDeclaration> formalParameters,
            List<? extends Type> exceptionTypes,
            Block body) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(typeParameters, "typeParameters"); //$NON-NLS-1$
        Util.notContainNull(typeParameters, "typeParameters"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(formalParameters, "formalParameters"); //$NON-NLS-1$
        Util.notContainNull(formalParameters, "formalParameters"); //$NON-NLS-1$
        Util.notNull(exceptionTypes, "exceptionTypes"); //$NON-NLS-1$
        Util.notContainNull(exceptionTypes, "exceptionTypes"); //$NON-NLS-1$
        Util.notNull(body, "body"); //$NON-NLS-1$
        ConstructorDeclarationImpl result = new ConstructorDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setModifiers(modifiers);
        result.setTypeParameters(typeParameters);
        result.setName(name);
        result.setFormalParameters(formalParameters);
        result.setExceptionTypes(exceptionTypes);
        result.setBody(body);
        return result;
    }

    @Override
    public ContinueStatement newContinueStatement() {
        return this.newContinueStatement0(
            null
        );
    }

    @Override
    public ContinueStatement newContinueStatement(
            SimpleName target) {
        return this.newContinueStatement0(
            target
        );
    }

    private ContinueStatementImpl newContinueStatement0(
            SimpleName target) {
        ContinueStatementImpl result = new ContinueStatementImpl();
        result.setTarget(target);
        return result;
    }

    @Override
    public DoStatement newDoStatement(
            Statement body,
            Expression condition) {
        return this.newDoStatement0(
            body,
            condition
        );
    }

    private DoStatementImpl newDoStatement0(
            Statement body,
            Expression condition) {
        Util.notNull(body, "body"); //$NON-NLS-1$
        Util.notNull(condition, "condition"); //$NON-NLS-1$
        DoStatementImpl result = new DoStatementImpl();
        result.setBody(body);
        result.setCondition(condition);
        return result;
    }

    @Override
    public DocBlock newDocBlock(
            String tag,
            List<? extends DocElement> elements) {
        return this.newDocBlock0(
            tag,
            elements
        );
    }

    private DocBlockImpl newDocBlock0(
            String tag,
            List<? extends DocElement> elements) {
        Util.notNull(tag, "tag"); //$NON-NLS-1$
        Util.notNull(elements, "elements"); //$NON-NLS-1$
        Util.notContainNull(elements, "elements"); //$NON-NLS-1$
        DocBlockImpl result = new DocBlockImpl();
        result.setTag(tag);
        result.setElements(elements);
        return result;
    }

    @Override
    public DocField newDocField(
            Type type,
            SimpleName name) {
        return this.newDocField0(
            type,
            name
        );
    }

    private DocFieldImpl newDocField0(
            Type type,
            SimpleName name) {
        Util.notNull(name, "name"); //$NON-NLS-1$
        DocFieldImpl result = new DocFieldImpl();
        result.setType(type);
        result.setName(name);
        return result;
    }

    @Override
    public DocMethod newDocMethod(
            Type type,
            SimpleName name,
            List<? extends DocMethodParameter> formalParameters) {
        return this.newDocMethod0(
            type,
            name,
            formalParameters
        );
    }

    private DocMethodImpl newDocMethod0(
            Type type,
            SimpleName name,
            List<? extends DocMethodParameter> formalParameters) {
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(formalParameters, "formalParameters"); //$NON-NLS-1$
        Util.notContainNull(formalParameters, "formalParameters"); //$NON-NLS-1$
        DocMethodImpl result = new DocMethodImpl();
        result.setType(type);
        result.setName(name);
        result.setFormalParameters(formalParameters);
        return result;
    }

    @Override
    public DocMethodParameter newDocMethodParameter(
            Type type,
            SimpleName name,
            boolean variableArity) {
        return this.newDocMethodParameter0(
            type,
            name,
            variableArity
        );
    }

    private DocMethodParameterImpl newDocMethodParameter0(
            Type type,
            SimpleName name,
            boolean variableArity) {
        Util.notNull(type, "type"); //$NON-NLS-1$
        DocMethodParameterImpl result = new DocMethodParameterImpl();
        result.setType(type);
        result.setName(name);
        result.setVariableArity(variableArity);
        return result;
    }

    @Override
    public DocText newDocText(
            String string) {
        return this.newDocText0(
            string
        );
    }

    private DocTextImpl newDocText0(
            String string) {
        Util.notNull(string, "string"); //$NON-NLS-1$
        DocTextImpl result = new DocTextImpl();
        result.setString(string);
        return result;
    }

    @Override
    public EmptyStatement newEmptyStatement(
            ) {
        return this.newEmptyStatement0(

        );
    }

    private EmptyStatementImpl newEmptyStatement0(
            ) {
        EmptyStatementImpl result = new EmptyStatementImpl();
        return result;
    }

    @Override
    public EnhancedForStatement newEnhancedForStatement(
            FormalParameterDeclaration parameter,
            Expression expression,
            Statement body) {
        return this.newEnhancedForStatement0(
            parameter,
            expression,
            body
        );
    }

    private EnhancedForStatementImpl newEnhancedForStatement0(
            FormalParameterDeclaration parameter,
            Expression expression,
            Statement body) {
        Util.notNull(parameter, "parameter"); //$NON-NLS-1$
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        Util.notNull(body, "body"); //$NON-NLS-1$
        EnhancedForStatementImpl result = new EnhancedForStatementImpl();
        result.setParameter(parameter);
        result.setExpression(expression);
        result.setBody(body);
        return result;
    }

    @Override
    public EnumConstantDeclaration newEnumConstantDeclaration(
            Javadoc javadoc,
            SimpleName name,
            Expression...arguments) {
        Util.notNull(arguments, "arguments"); //$NON-NLS-1$
        return this.newEnumConstantDeclaration0(
            javadoc,
            Collections.<Attribute>emptyList(),
            name,
            Arrays.asList(arguments),
            null
        );
    }

    @Override
    public EnumConstantDeclaration newEnumConstantDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends Expression> arguments,
            ClassBody body) {
        return this.newEnumConstantDeclaration0(
            javadoc,
            modifiers,
            name,
            arguments,
            body
        );
    }

    private EnumConstantDeclarationImpl newEnumConstantDeclaration0(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends Expression> arguments,
            ClassBody body) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(arguments, "arguments"); //$NON-NLS-1$
        Util.notContainNull(arguments, "arguments"); //$NON-NLS-1$
        EnumConstantDeclarationImpl result = new EnumConstantDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setModifiers(modifiers);
        result.setName(name);
        result.setArguments(arguments);
        result.setBody(body);
        return result;
    }

    @Override
    public EnumDeclaration newEnumDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends EnumConstantDeclaration> constantDeclarations,
            TypeBodyDeclaration...bodyDeclarations) {
        Util.notNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        return this.newEnumDeclaration0(
            javadoc,
            modifiers,
            name,
            Collections.<Type>emptyList(),
            constantDeclarations,
            Arrays.asList(bodyDeclarations)
        );
    }

    @Override
    public EnumDeclaration newEnumDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends Type> superInterfaceTypes,
            List<? extends EnumConstantDeclaration> constantDeclarations,
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        return this.newEnumDeclaration0(
            javadoc,
            modifiers,
            name,
            superInterfaceTypes,
            constantDeclarations,
            bodyDeclarations
        );
    }

    private EnumDeclarationImpl newEnumDeclaration0(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends Type> superInterfaceTypes,
            List<? extends EnumConstantDeclaration> constantDeclarations,
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(superInterfaceTypes, "superInterfaceTypes"); //$NON-NLS-1$
        Util.notContainNull(superInterfaceTypes, "superInterfaceTypes"); //$NON-NLS-1$
        Util.notNull(constantDeclarations, "constantDeclarations"); //$NON-NLS-1$
        Util.notContainNull(constantDeclarations, "constantDeclarations"); //$NON-NLS-1$
        Util.notNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        Util.notContainNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        EnumDeclarationImpl result = new EnumDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setModifiers(modifiers);
        result.setName(name);
        result.setSuperInterfaceTypes(superInterfaceTypes);
        result.setConstantDeclarations(constantDeclarations);
        result.setBodyDeclarations(bodyDeclarations);
        return result;
    }

    @Override
    public ExpressionStatement newExpressionStatement(
            Expression expression) {
        return this.newExpressionStatement0(
            expression
        );
    }

    private ExpressionStatementImpl newExpressionStatement0(
            Expression expression) {
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        ExpressionStatementImpl result = new ExpressionStatementImpl();
        result.setExpression(expression);
        return result;
    }

    @Override
    public FieldAccessExpression newFieldAccessExpression(
            Expression qualifier,
            SimpleName name) {
        return this.newFieldAccessExpression0(
            qualifier,
            name
        );
    }

    private FieldAccessExpressionImpl newFieldAccessExpression0(
            Expression qualifier,
            SimpleName name) {
        Util.notNull(qualifier, "qualifier"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        FieldAccessExpressionImpl result = new FieldAccessExpressionImpl();
        result.setQualifier(parenthesize(qualifier, ExpressionPriority.PRIMARY));
        result.setName(name);
        return result;
    }

    @Override
    public FieldDeclaration newFieldDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            Type type,
            SimpleName name,
            Expression initializer) {
        return this.newFieldDeclaration0(
            javadoc,
            modifiers,
            type,
            Collections.singletonList(newVariableDeclarator(
                name,
                0,
                initializer))
        );
    }

    @Override
    public FieldDeclaration newFieldDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            Type type,
            List<? extends VariableDeclarator> variableDeclarators) {
        return this.newFieldDeclaration0(
            javadoc,
            modifiers,
            type,
            variableDeclarators
        );
    }

    private FieldDeclarationImpl newFieldDeclaration0(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            Type type,
            List<? extends VariableDeclarator> variableDeclarators) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(type, "type"); //$NON-NLS-1$
        Util.notNull(variableDeclarators, "variableDeclarators"); //$NON-NLS-1$
        Util.notContainNull(variableDeclarators, "variableDeclarators"); //$NON-NLS-1$
        Util.notEmpty(variableDeclarators, "variableDeclarators"); //$NON-NLS-1$
        FieldDeclarationImpl result = new FieldDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setModifiers(modifiers);
        result.setType(type);
        result.setVariableDeclarators(variableDeclarators);
        return result;
    }

    @Override
    public ForStatement newForStatement(
            ForInitializer initialization,
            Expression condition,
            StatementExpressionList update,
            Statement body) {
        return this.newForStatement0(
            initialization,
            condition,
            update,
            body
        );
    }

    private ForStatementImpl newForStatement0(
            ForInitializer initialization,
            Expression condition,
            StatementExpressionList update,
            Statement body) {
        Util.notNull(body, "body"); //$NON-NLS-1$
        ForStatementImpl result = new ForStatementImpl();
        result.setInitialization(initialization);
        result.setCondition(condition);
        result.setUpdate(update);
        result.setBody(body);
        return result;
    }

    @Override
    public FormalParameterDeclaration newFormalParameterDeclaration(
            Type type,
            SimpleName name) {
        return this.newFormalParameterDeclaration0(
            Collections.<Attribute>emptyList(),
            type,
            false,
            name,
            0
        );
    }

    @Override
    public FormalParameterDeclaration newFormalParameterDeclaration(
            List<? extends Attribute> modifiers,
            Type type,
            boolean variableArity,
            SimpleName name,
            int extraDimensions) {
        return this.newFormalParameterDeclaration0(
            modifiers,
            type,
            variableArity,
            name,
            extraDimensions
        );
    }

    private FormalParameterDeclarationImpl newFormalParameterDeclaration0(
            List<? extends Attribute> modifiers,
            Type type,
            boolean variableArity,
            SimpleName name,
            int extraDimensions) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(type, "type"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        FormalParameterDeclarationImpl result = new FormalParameterDeclarationImpl();
        result.setModifiers(modifiers);
        result.setType(type);
        result.setVariableArity(variableArity);
        result.setName(name);
        result.setExtraDimensions(extraDimensions);
        return result;
    }

    @Override
    public IfStatement newIfStatement(
            Expression condition,
            Statement thenStatement) {
        return this.newIfStatement0(
            condition,
            thenStatement,
            null
        );
    }

    @Override
    public IfStatement newIfStatement(
            Expression condition,
            Statement thenStatement,
            Statement elseStatement) {
        return this.newIfStatement0(
            condition,
            thenStatement,
            elseStatement
        );
    }

    private IfStatementImpl newIfStatement0(
            Expression condition,
            Statement thenStatement,
            Statement elseStatement) {
        Util.notNull(condition, "condition"); //$NON-NLS-1$
        Util.notNull(thenStatement, "thenStatement"); //$NON-NLS-1$
        IfStatementImpl result = new IfStatementImpl();
        result.setCondition(condition);
        result.setThenStatement(thenStatement);
        result.setElseStatement(elseStatement);
        return result;
    }

    @Override
    public ImportDeclaration newImportDeclaration(
            ImportKind importKind,
            Name name) {
        return this.newImportDeclaration0(
            importKind,
            name
        );
    }

    private ImportDeclarationImpl newImportDeclaration0(
            ImportKind importKind,
            Name name) {
        Util.notNull(importKind, "importKind"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        ImportDeclarationImpl result = new ImportDeclarationImpl();
        result.setImportKind(importKind);
        result.setName(name);
        return result;
    }

    @Override
    public InfixExpression newInfixExpression(
            Expression leftOperand,
            InfixOperator operator,
            Expression rightOperand) {
        return this.newInfixExpression0(
            leftOperand,
            operator,
            rightOperand
        );
    }

    private InfixExpressionImpl newInfixExpression0(
            Expression leftOperand,
            InfixOperator operator,
            Expression rightOperand) {
        Util.notNull(leftOperand, "leftOperand"); //$NON-NLS-1$
        Util.notNull(operator, "operator"); //$NON-NLS-1$
        Util.notNull(rightOperand, "rightOperand"); //$NON-NLS-1$
        InfixExpressionImpl result = new InfixExpressionImpl();
        result.setLeftOperand(parenthesize(leftOperand, ExpressionPriority.valueOf(operator)));
        result.setOperator(operator);
        result.setRightOperand(parenthesizeRight(rightOperand, ExpressionPriority.valueOf(operator)));
        return result;
    }

    @Override
    public InitializerDeclaration newInitializerDeclaration(
            List<? extends Statement> statements) {
        Util.notNull(statements, "statements"); //$NON-NLS-1$
        return this.newInitializerDeclaration0(
            null,
            Collections.<Attribute>emptyList(),
            newBlock(statements)
        );
    }

    @Override
    public InitializerDeclaration newInitializerDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            Block body) {
        return this.newInitializerDeclaration0(
            javadoc,
            modifiers,
            body
        );
    }

    private InitializerDeclarationImpl newInitializerDeclaration0(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            Block body) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(body, "body"); //$NON-NLS-1$
        InitializerDeclarationImpl result = new InitializerDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setModifiers(modifiers);
        result.setBody(body);
        return result;
    }

    @Override
    public InstanceofExpression newInstanceofExpression(
            Expression expression,
            Type type) {
        return this.newInstanceofExpression0(
            expression,
            type
        );
    }

    private InstanceofExpressionImpl newInstanceofExpression0(
            Expression expression,
            Type type) {
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        Util.notNull(type, "type"); //$NON-NLS-1$
        InstanceofExpressionImpl result = new InstanceofExpressionImpl();
        result.setExpression(parenthesize(expression, ExpressionPriority.RELATIONAL));
        result.setType(type);
        return result;
    }

    @Override
    public InterfaceDeclaration newInterfaceDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends Type> superInterfaceTypes,
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        return this.newInterfaceDeclaration0(
            javadoc,
            modifiers,
            name,
            Collections.<TypeParameterDeclaration>emptyList(),
            superInterfaceTypes,
            bodyDeclarations
        );
    }

    @Override
    public InterfaceDeclaration newInterfaceDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends TypeParameterDeclaration> typeParameters,
            List<? extends Type> superInterfaceTypes,
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        return this.newInterfaceDeclaration0(
            javadoc,
            modifiers,
            name,
            typeParameters,
            superInterfaceTypes,
            bodyDeclarations
        );
    }

    private InterfaceDeclarationImpl newInterfaceDeclaration0(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            SimpleName name,
            List<? extends TypeParameterDeclaration> typeParameters,
            List<? extends Type> superInterfaceTypes,
            List<? extends TypeBodyDeclaration> bodyDeclarations) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(typeParameters, "typeParameters"); //$NON-NLS-1$
        Util.notContainNull(typeParameters, "typeParameters"); //$NON-NLS-1$
        Util.notNull(superInterfaceTypes, "superInterfaceTypes"); //$NON-NLS-1$
        Util.notContainNull(superInterfaceTypes, "superInterfaceTypes"); //$NON-NLS-1$
        Util.notNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        Util.notContainNull(bodyDeclarations, "bodyDeclarations"); //$NON-NLS-1$
        InterfaceDeclarationImpl result = new InterfaceDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setModifiers(modifiers);
        result.setName(name);
        result.setTypeParameters(typeParameters);
        result.setSuperInterfaceTypes(superInterfaceTypes);
        result.setBodyDeclarations(bodyDeclarations);
        return result;
    }

    @Override
    public Javadoc newJavadoc(
            List<? extends DocBlock> blocks) {
        return this.newJavadoc0(
            blocks
        );
    }

    private JavadocImpl newJavadoc0(
            List<? extends DocBlock> blocks) {
        Util.notNull(blocks, "blocks"); //$NON-NLS-1$
        Util.notContainNull(blocks, "blocks"); //$NON-NLS-1$
        JavadocImpl result = new JavadocImpl();
        result.setBlocks(blocks);
        return result;
    }

    @Override
    public LabeledStatement newLabeledStatement(
            SimpleName label,
            Statement body) {
        return this.newLabeledStatement0(
            label,
            body
        );
    }

    private LabeledStatementImpl newLabeledStatement0(
            SimpleName label,
            Statement body) {
        Util.notNull(label, "label"); //$NON-NLS-1$
        Util.notNull(body, "body"); //$NON-NLS-1$
        LabeledStatementImpl result = new LabeledStatementImpl();
        result.setLabel(label);
        result.setBody(body);
        return result;
    }

    @Override
    public LineComment newLineComment(
            String string) {
        return this.newLineComment0(
            string
        );
    }

    private LineCommentImpl newLineComment0(
            String string) {
        Util.notNull(string, "string"); //$NON-NLS-1$
        LineCommentImpl result = new LineCommentImpl();
        result.setString(string);
        return result;
    }

    @Override
    public Literal newLiteral(
            String token) {
        return this.newLiteral0(
            token
        );
    }

    private LiteralImpl newLiteral0(
            String token) {
        Util.notNull(token, "token"); //$NON-NLS-1$
        LiteralImpl result = new LiteralImpl();
        result.setToken(token);
        return result;
    }

    @Override
    public LocalClassDeclaration newLocalClassDeclaration(
            ClassDeclaration declaration) {
        return this.newLocalClassDeclaration0(
            declaration
        );
    }

    private LocalClassDeclarationImpl newLocalClassDeclaration0(
            ClassDeclaration declaration) {
        Util.notNull(declaration, "declaration"); //$NON-NLS-1$
        LocalClassDeclarationImpl result = new LocalClassDeclarationImpl();
        result.setDeclaration(declaration);
        return result;
    }

    @Override
    public LocalVariableDeclaration newLocalVariableDeclaration(
            Type type,
            SimpleName name,
            Expression initializer) {
        return this.newLocalVariableDeclaration0(
            Collections.<Attribute>emptyList(),
            type,
            Collections.singletonList(newVariableDeclarator(
                name,
                0,
                initializer))
        );
    }

    @Override
    public LocalVariableDeclaration newLocalVariableDeclaration(
            List<? extends Attribute> modifiers,
            Type type,
            List<? extends VariableDeclarator> variableDeclarators) {
        return this.newLocalVariableDeclaration0(
            modifiers,
            type,
            variableDeclarators
        );
    }

    private LocalVariableDeclarationImpl newLocalVariableDeclaration0(
            List<? extends Attribute> modifiers,
            Type type,
            List<? extends VariableDeclarator> variableDeclarators) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(type, "type"); //$NON-NLS-1$
        Util.notNull(variableDeclarators, "variableDeclarators"); //$NON-NLS-1$
        Util.notContainNull(variableDeclarators, "variableDeclarators"); //$NON-NLS-1$
        Util.notEmpty(variableDeclarators, "variableDeclarators"); //$NON-NLS-1$
        LocalVariableDeclarationImpl result = new LocalVariableDeclarationImpl();
        result.setModifiers(modifiers);
        result.setType(type);
        result.setVariableDeclarators(variableDeclarators);
        return result;
    }

    @Override
    public MarkerAnnotation newMarkerAnnotation(
            NamedType type) {
        return this.newMarkerAnnotation0(
            type
        );
    }

    private MarkerAnnotationImpl newMarkerAnnotation0(
            NamedType type) {
        Util.notNull(type, "type"); //$NON-NLS-1$
        MarkerAnnotationImpl result = new MarkerAnnotationImpl();
        result.setType(type);
        return result;
    }

    @Override
    public MethodDeclaration newMethodDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            Type returnType,
            SimpleName name,
            List<? extends FormalParameterDeclaration> formalParameters,
            List<? extends Statement> statements) {
        Util.notNull(statements, "statements"); //$NON-NLS-1$
        return this.newMethodDeclaration0(
            javadoc,
            modifiers,
            Collections.<TypeParameterDeclaration>emptyList(),
            returnType,
            name,
            formalParameters,
            0,
            Collections.<Type>emptyList(),
            newBlock(statements)
        );
    }

    @Override
    public MethodDeclaration newMethodDeclaration(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            List<? extends TypeParameterDeclaration> typeParameters,
            Type returnType,
            SimpleName name,
            List<? extends FormalParameterDeclaration> formalParameters,
            int extraDimensions,
            List<? extends Type> exceptionTypes,
            Block body) {
        return this.newMethodDeclaration0(
            javadoc,
            modifiers,
            typeParameters,
            returnType,
            name,
            formalParameters,
            extraDimensions,
            exceptionTypes,
            body
        );
    }

    private MethodDeclarationImpl newMethodDeclaration0(
            Javadoc javadoc,
            List<? extends Attribute> modifiers,
            List<? extends TypeParameterDeclaration> typeParameters,
            Type returnType,
            SimpleName name,
            List<? extends FormalParameterDeclaration> formalParameters,
            int extraDimensions,
            List<? extends Type> exceptionTypes,
            Block body) {
        Util.notNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notContainNull(modifiers, "modifiers"); //$NON-NLS-1$
        Util.notNull(typeParameters, "typeParameters"); //$NON-NLS-1$
        Util.notContainNull(typeParameters, "typeParameters"); //$NON-NLS-1$
        Util.notNull(returnType, "returnType"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(formalParameters, "formalParameters"); //$NON-NLS-1$
        Util.notContainNull(formalParameters, "formalParameters"); //$NON-NLS-1$
        Util.notNull(exceptionTypes, "exceptionTypes"); //$NON-NLS-1$
        Util.notContainNull(exceptionTypes, "exceptionTypes"); //$NON-NLS-1$
        MethodDeclarationImpl result = new MethodDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setModifiers(modifiers);
        result.setTypeParameters(typeParameters);
        result.setReturnType(returnType);
        result.setName(name);
        result.setFormalParameters(formalParameters);
        result.setExtraDimensions(extraDimensions);
        result.setExceptionTypes(exceptionTypes);
        result.setBody(body);
        return result;
    }

    @Override
    public MethodInvocationExpression newMethodInvocationExpression(
            Expression qualifier,
            SimpleName name,
            Expression...arguments) {
        Util.notNull(arguments, "arguments"); //$NON-NLS-1$
        return this.newMethodInvocationExpression0(
            qualifier,
            Collections.<Type>emptyList(),
            name,
            Arrays.asList(arguments)
        );
    }

    @Override
    public MethodInvocationExpression newMethodInvocationExpression(
            Expression qualifier,
            SimpleName name,
            List<? extends Expression> arguments) {
        return this.newMethodInvocationExpression0(
            qualifier,
            Collections.<Type>emptyList(),
            name,
            arguments
        );
    }

    @Override
    public MethodInvocationExpression newMethodInvocationExpression(
            Expression qualifier,
            List<? extends Type> typeArguments,
            SimpleName name,
            List<? extends Expression> arguments) {
        return this.newMethodInvocationExpression0(
            qualifier,
            typeArguments,
            name,
            arguments
        );
    }

    private MethodInvocationExpressionImpl newMethodInvocationExpression0(
            Expression qualifier,
            List<? extends Type> typeArguments,
            SimpleName name,
            List<? extends Expression> arguments) {
        Util.notNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        Util.notContainNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(arguments, "arguments"); //$NON-NLS-1$
        Util.notContainNull(arguments, "arguments"); //$NON-NLS-1$
        MethodInvocationExpressionImpl result = new MethodInvocationExpressionImpl();
        result.setQualifier(parenthesize(qualifier, ExpressionPriority.PRIMARY));
        result.setTypeArguments(typeArguments);
        result.setName(name);
        result.setArguments(arguments);
        return result;
    }

    @Override
    public Modifier newModifier(
            ModifierKind modifierKind) {
        return this.newModifier0(
            modifierKind
        );
    }

    private ModifierImpl newModifier0(
            ModifierKind modifierKind) {
        Util.notNull(modifierKind, "modifierKind"); //$NON-NLS-1$
        ModifierImpl result = new ModifierImpl();
        result.setModifierKind(modifierKind);
        return result;
    }

    @Override
    public NamedType newNamedType(
            Name name) {
        return this.newNamedType0(
            name
        );
    }

    private NamedTypeImpl newNamedType0(
            Name name) {
        Util.notNull(name, "name"); //$NON-NLS-1$
        NamedTypeImpl result = new NamedTypeImpl();
        result.setName(name);
        return result;
    }

    @Override
    public NormalAnnotation newNormalAnnotation(
            NamedType type,
            List<? extends AnnotationElement> elements) {
        return this.newNormalAnnotation0(
            type,
            elements
        );
    }

    private NormalAnnotationImpl newNormalAnnotation0(
            NamedType type,
            List<? extends AnnotationElement> elements) {
        Util.notNull(type, "type"); //$NON-NLS-1$
        Util.notNull(elements, "elements"); //$NON-NLS-1$
        Util.notContainNull(elements, "elements"); //$NON-NLS-1$
        NormalAnnotationImpl result = new NormalAnnotationImpl();
        result.setType(type);
        result.setElements(elements);
        return result;
    }

    @Override
    public PackageDeclaration newPackageDeclaration(Name name) {
        return this.newPackageDeclaration0(
            null,
            Collections.<Annotation>emptyList(),
            name
        );
    }

    @Override
    public PackageDeclaration newPackageDeclaration(
            Javadoc javadoc,
            List<? extends Annotation> annotations,
            Name name) {
        return this.newPackageDeclaration0(
            javadoc,
            annotations,
            name
        );
    }

    private PackageDeclarationImpl newPackageDeclaration0(
            Javadoc javadoc,
            List<? extends Annotation> annotations,
            Name name) {
        Util.notNull(annotations, "annotations"); //$NON-NLS-1$
        Util.notContainNull(annotations, "annotations"); //$NON-NLS-1$
        Util.notNull(name, "name"); //$NON-NLS-1$
        PackageDeclarationImpl result = new PackageDeclarationImpl();
        result.setJavadoc(javadoc);
        result.setAnnotations(annotations);
        result.setName(name);
        return result;
    }

    @Override
    public ParameterizedType newParameterizedType(
            Type type,
            Type...typeArguments) {
        Util.notNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        return this.newParameterizedType0(
            type,
            Arrays.asList(typeArguments)
        );
    }

    @Override
    public ParameterizedType newParameterizedType(
            Type type,
            List<? extends Type> typeArguments) {
        return this.newParameterizedType0(
            type,
            typeArguments
        );
    }

    private ParameterizedTypeImpl newParameterizedType0(
            Type type,
            List<? extends Type> typeArguments) {
        Util.notNull(type, "type"); //$NON-NLS-1$
        Util.notNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        Util.notContainNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        Util.notEmpty(typeArguments, "typeArguments"); //$NON-NLS-1$
        ParameterizedTypeImpl result = new ParameterizedTypeImpl();
        result.setType(type);
        result.setTypeArguments(typeArguments);
        return result;
    }

    @Override
    public ParenthesizedExpression newParenthesizedExpression(
            Expression expression) {
        return this.newParenthesizedExpression0(
            expression
        );
    }

    private ParenthesizedExpressionImpl newParenthesizedExpression0(
            Expression expression) {
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        ParenthesizedExpressionImpl result = new ParenthesizedExpressionImpl();
        result.setExpression(expression);
        return result;
    }

    @Override
    public PostfixExpression newPostfixExpression(
            Expression operand,
            PostfixOperator operator) {
        return this.newPostfixExpression0(
            operand,
            operator
        );
    }

    private PostfixExpressionImpl newPostfixExpression0(
            Expression operand,
            PostfixOperator operator) {
        Util.notNull(operand, "operand"); //$NON-NLS-1$
        Util.notNull(operator, "operator"); //$NON-NLS-1$
        PostfixExpressionImpl result = new PostfixExpressionImpl();
        result.setOperand(parenthesize(operand, ExpressionPriority.UNARY));
        result.setOperator(operator);
        return result;
    }

    @Override
    public QualifiedName newQualifiedName(
            Name qualifier,
            SimpleName simpleName) {
        return this.newQualifiedName0(
            qualifier,
            simpleName
        );
    }

    private QualifiedNameImpl newQualifiedName0(
            Name qualifier,
            SimpleName simpleName) {
        Util.notNull(qualifier, "qualifier"); //$NON-NLS-1$
        Util.notNull(simpleName, "simpleName"); //$NON-NLS-1$
        QualifiedNameImpl result = new QualifiedNameImpl();
        result.setQualifier(qualifier);
        result.setSimpleName(simpleName);
        return result;
    }

    @Override
    public QualifiedType newQualifiedType(
            Type qualifier,
            SimpleName simpleName) {
        return this.newQualifiedType0(
            qualifier,
            simpleName
        );
    }

    private QualifiedTypeImpl newQualifiedType0(
            Type qualifier,
            SimpleName simpleName) {
        Util.notNull(qualifier, "qualifier"); //$NON-NLS-1$
        Util.notNull(simpleName, "simpleName"); //$NON-NLS-1$
        QualifiedTypeImpl result = new QualifiedTypeImpl();
        result.setQualifier(qualifier);
        result.setSimpleName(simpleName);
        return result;
    }

    @Override
    public ReturnStatement newReturnStatement() {
        return this.newReturnStatement0(
            null
        );
    }

    @Override
    public ReturnStatement newReturnStatement(
            Expression expression) {
        return this.newReturnStatement0(
            expression
        );
    }

    private ReturnStatementImpl newReturnStatement0(
            Expression expression) {
        ReturnStatementImpl result = new ReturnStatementImpl();
        result.setExpression(expression);
        return result;
    }

    @Override
    public SimpleName newSimpleName(
            String string) {
        return this.newSimpleName0(
            string
        );
    }

    private SimpleNameImpl newSimpleName0(
            String string) {
        Util.notNull(string, "string"); //$NON-NLS-1$
        SimpleNameImpl result = new SimpleNameImpl();
        result.setToken(string);
        return result;
    }

    @Override
    public SingleElementAnnotation newSingleElementAnnotation(
            NamedType type,
            Expression expression) {
        return this.newSingleElementAnnotation0(
            type,
            expression
        );
    }

    private SingleElementAnnotationImpl newSingleElementAnnotation0(
            NamedType type,
            Expression expression) {
        Util.notNull(type, "type"); //$NON-NLS-1$
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        SingleElementAnnotationImpl result = new SingleElementAnnotationImpl();
        result.setType(type);
        result.setExpression(expression);
        return result;
    }

    @Override
    public StatementExpressionList newStatementExpressionList(
            Expression...expressions) {
        Util.notNull(expressions, "expressions"); //$NON-NLS-1$
        return this.newStatementExpressionList0(
            Arrays.asList(expressions)
        );
    }

    @Override
    public StatementExpressionList newStatementExpressionList(
            List<? extends Expression> expressions) {
        return this.newStatementExpressionList0(
            expressions
        );
    }

    private StatementExpressionListImpl newStatementExpressionList0(
            List<? extends Expression> expressions) {
        Util.notNull(expressions, "expressions"); //$NON-NLS-1$
        Util.notContainNull(expressions, "expressions"); //$NON-NLS-1$
        Util.notEmpty(expressions, "expressions"); //$NON-NLS-1$
        StatementExpressionListImpl result = new StatementExpressionListImpl();
        result.setExpressions(expressions);
        return result;
    }

    @Override
    public Super newSuper() {
        return this.newSuper0(
            null
        );
    }

    @Override
    public Super newSuper(
            NamedType qualifier) {
        return this.newSuper0(
            qualifier
        );
    }

    private SuperImpl newSuper0(
            NamedType qualifier) {
        SuperImpl result = new SuperImpl();
        result.setQualifier(qualifier);
        return result;
    }

    @Override
    public SuperConstructorInvocation newSuperConstructorInvocation(
            Expression...arguments) {
        Util.notNull(arguments, "arguments"); //$NON-NLS-1$
        return this.newSuperConstructorInvocation0(
            null,
            Collections.<Type>emptyList(),
            Arrays.asList(arguments)
        );
    }

    @Override
    public SuperConstructorInvocation newSuperConstructorInvocation(
            List<? extends Expression> arguments) {
        return this.newSuperConstructorInvocation0(
            null,
            Collections.<Type>emptyList(),
            arguments
        );
    }

    @Override
    public SuperConstructorInvocation newSuperConstructorInvocation(
            Expression qualifier,
            List<? extends Type> typeArguments,
            List<? extends Expression> arguments) {
        return this.newSuperConstructorInvocation0(
            qualifier,
            typeArguments,
            arguments
        );
    }

    private SuperConstructorInvocationImpl newSuperConstructorInvocation0(
            Expression qualifier,
            List<? extends Type> typeArguments,
            List<? extends Expression> arguments) {
        Util.notNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        Util.notContainNull(typeArguments, "typeArguments"); //$NON-NLS-1$
        Util.notNull(arguments, "arguments"); //$NON-NLS-1$
        Util.notContainNull(arguments, "arguments"); //$NON-NLS-1$
        SuperConstructorInvocationImpl result = new SuperConstructorInvocationImpl();
        result.setQualifier(parenthesize(qualifier, ExpressionPriority.PRIMARY));
        result.setTypeArguments(typeArguments);
        result.setArguments(arguments);
        return result;
    }

    @Override
    public SwitchCaseLabel newSwitchCaseLabel(
            Expression expression) {
        return this.newSwitchCaseLabel0(
            expression
        );
    }

    private SwitchCaseLabelImpl newSwitchCaseLabel0(
            Expression expression) {
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        SwitchCaseLabelImpl result = new SwitchCaseLabelImpl();
        result.setExpression(expression);
        return result;
    }

    @Override
    public SwitchDefaultLabel newSwitchDefaultLabel(
            ) {
        return this.newSwitchDefaultLabel0(

        );
    }

    private SwitchDefaultLabelImpl newSwitchDefaultLabel0(
            ) {
        SwitchDefaultLabelImpl result = new SwitchDefaultLabelImpl();
        return result;
    }

    @Override
    public SwitchStatement newSwitchStatement(
            Expression expression,
            List<? extends Statement> statements) {
        return this.newSwitchStatement0(
            expression,
            statements
        );
    }

    private SwitchStatementImpl newSwitchStatement0(
            Expression expression,
            List<? extends Statement> statements) {
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        Util.notNull(statements, "statements"); //$NON-NLS-1$
        Util.notContainNull(statements, "statements"); //$NON-NLS-1$
        SwitchStatementImpl result = new SwitchStatementImpl();
        result.setExpression(expression);
        result.setStatements(statements);
        return result;
    }

    @Override
    public SynchronizedStatement newSynchronizedStatement(
            Expression expression,
            Block body) {
        return this.newSynchronizedStatement0(
            expression,
            body
        );
    }

    private SynchronizedStatementImpl newSynchronizedStatement0(
            Expression expression,
            Block body) {
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        Util.notNull(body, "body"); //$NON-NLS-1$
        SynchronizedStatementImpl result = new SynchronizedStatementImpl();
        result.setExpression(expression);
        result.setBody(body);
        return result;
    }

    @Override
    public This newThis() {
        return this.newThis0(
            null
        );
    }

    @Override
    public This newThis(
            NamedType qualifier) {
        return this.newThis0(
            qualifier
        );
    }

    private ThisImpl newThis0(
            NamedType qualifier) {
        ThisImpl result = new ThisImpl();
        result.setQualifier(qualifier);
        return result;
    }

    @Override
    public ThrowStatement newThrowStatement(
            Expression expression) {
        return this.newThrowStatement0(
            expression
        );
    }

    private ThrowStatementImpl newThrowStatement0(
            Expression expression) {
        Util.notNull(expression, "expression"); //$NON-NLS-1$
        ThrowStatementImpl result = new ThrowStatementImpl();
        result.setExpression(expression);
        return result;
    }

    @Override
    public TryStatement newTryStatement(
            Block tryBlock,
            List<? extends CatchClause> catchClauses,
            Block finallyBlock) {
        return this.newTryStatement0(
            tryBlock,
            catchClauses,
            finallyBlock
        );
    }

    private TryStatementImpl newTryStatement0(
            Block tryBlock,
            List<? extends CatchClause> catchClauses,
            Block finallyBlock) {
        Util.notNull(tryBlock, "tryBlock"); //$NON-NLS-1$
        Util.notNull(catchClauses, "catchClauses"); //$NON-NLS-1$
        Util.notContainNull(catchClauses, "catchClauses"); //$NON-NLS-1$
        TryStatementImpl result = new TryStatementImpl();
        result.setTryBlock(tryBlock);
        result.setCatchClauses(catchClauses);
        result.setFinallyBlock(finallyBlock);
        return result;
    }

    @Override
    public TypeParameterDeclaration newTypeParameterDeclaration(
            SimpleName name,
            Type...typeBounds) {
        Util.notNull(typeBounds, "typeBounds"); //$NON-NLS-1$
        return this.newTypeParameterDeclaration0(
            name,
            Arrays.asList(typeBounds)
        );
    }

    @Override
    public TypeParameterDeclaration newTypeParameterDeclaration(
            SimpleName name,
            List<? extends Type> typeBounds) {
        return this.newTypeParameterDeclaration0(
            name,
            typeBounds
        );
    }

    private TypeParameterDeclarationImpl newTypeParameterDeclaration0(
            SimpleName name,
            List<? extends Type> typeBounds) {
        Util.notNull(name, "name"); //$NON-NLS-1$
        Util.notNull(typeBounds, "typeBounds"); //$NON-NLS-1$
        Util.notContainNull(typeBounds, "typeBounds"); //$NON-NLS-1$
        TypeParameterDeclarationImpl result = new TypeParameterDeclarationImpl();
        result.setName(name);
        result.setTypeBounds(typeBounds);
        return result;
    }

    @Override
    public UnaryExpression newUnaryExpression(
            UnaryOperator operator,
            Expression operand) {
        return this.newUnaryExpression0(
            operator,
            operand
        );
    }

    private UnaryExpressionImpl newUnaryExpression0(
            UnaryOperator operator,
            Expression operand) {
        Util.notNull(operator, "operator"); //$NON-NLS-1$
        Util.notNull(operand, "operand"); //$NON-NLS-1$
        UnaryExpressionImpl result = new UnaryExpressionImpl();
        result.setOperator(operator);
        result.setOperand(parenthesize(operand, ExpressionPriority.UNARY));
        return result;
    }

    @Override
    public VariableDeclarator newVariableDeclarator(
            SimpleName name,
            Expression initializer) {
        return this.newVariableDeclarator0(
            name,
            0,
            initializer
        );
    }

    @Override
    public VariableDeclarator newVariableDeclarator(
            SimpleName name,
            int extraDimensions,
            Expression initializer) {
        return this.newVariableDeclarator0(
            name,
            extraDimensions,
            initializer
        );
    }

    private VariableDeclaratorImpl newVariableDeclarator0(
            SimpleName name,
            int extraDimensions,
            Expression initializer) {
        Util.notNull(name, "name"); //$NON-NLS-1$
        VariableDeclaratorImpl result = new VariableDeclaratorImpl();
        result.setName(name);
        result.setExtraDimensions(extraDimensions);
        result.setInitializer(initializer);
        return result;
    }

    @Override
    public WhileStatement newWhileStatement(
            Expression condition,
            Statement body) {
        return this.newWhileStatement0(
            condition,
            body
        );
    }

    private WhileStatementImpl newWhileStatement0(
            Expression condition,
            Statement body) {
        Util.notNull(condition, "condition"); //$NON-NLS-1$
        Util.notNull(body, "body"); //$NON-NLS-1$
        WhileStatementImpl result = new WhileStatementImpl();
        result.setCondition(condition);
        result.setBody(body);
        return result;
    }

    @Override
    public Wildcard newWildcard() {
        return this.newWildcard0(
            WildcardBoundKind.UNBOUNDED,
            null
        );
    }

    @Override
    public Wildcard newWildcard(
            WildcardBoundKind boundKind,
            Type typeBound) {
        return this.newWildcard0(
            boundKind,
            typeBound
        );
    }

    private WildcardImpl newWildcard0(
            WildcardBoundKind boundKind,
            Type typeBound) {
        Util.notNull(boundKind, "boundKind"); //$NON-NLS-1$
        WildcardImpl result = new WildcardImpl();
        result.setBoundKind(boundKind);
        result.setTypeBound(typeBound);
        return result;
    }

    private Expression parenthesize(Expression expression, ExpressionPriority context) {
        if (expression == null) {
            return null;
        }
        ExpressionPriority priority = ExpressionPriority.valueOf(expression);
        if (ExpressionPriority.isParenthesesRequired(context, false, priority)) {
            return newParenthesizedExpression0(expression);
        } else {
            return expression;
        }
    }

    private Expression parenthesizeRight(Expression expression, ExpressionPriority context) {
        if (expression == null) {
            return null;
        }
        ExpressionPriority priority = ExpressionPriority.valueOf(expression);
        if (ExpressionPriority.isParenthesesRequired(context, true, priority)) {
            return newParenthesizedExpression0(expression);
        } else {
            return expression;
        }
    }
}
//CHECKSTYLE:ON