JdtRecorder.java

/*
 * ModeShape (http://www.modeshape.org)
 *
 * 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 org.modeshape.sequencer.javafile;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import javax.jcr.Node;
import javax.jcr.Value;
import javax.jcr.ValueFactory;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
import org.eclipse.jdt.core.dom.Annotation;
import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration;
import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.jdt.core.dom.ArrayType;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.BooleanLiteral;
import org.eclipse.jdt.core.dom.CharacterLiteral;
import org.eclipse.jdt.core.dom.Comment;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.EnumConstantDeclaration;
import org.eclipse.jdt.core.dom.EnumDeclaration;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.IExtendedModifier;
import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.Initializer;
import org.eclipse.jdt.core.dom.Javadoc;
import org.eclipse.jdt.core.dom.MemberValuePair;
import org.eclipse.jdt.core.dom.Message;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.NormalAnnotation;
import org.eclipse.jdt.core.dom.PackageDeclaration;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.QualifiedType;
import org.eclipse.jdt.core.dom.SimpleType;
import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.TypeParameter;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.WildcardType;
import org.modeshape.common.logging.Logger;
import org.modeshape.common.util.StringUtil;
import org.modeshape.jcr.api.sequencer.Sequencer;
import org.modeshape.jcr.api.sequencer.Sequencer.Context;
import org.modeshape.sequencer.classfile.ClassFileSequencerLexicon;
import org.modeshape.sequencer.classfile.metadata.Visibility;

/**
 * An Eclipse JDT DOM to JCR node recorder.
 *
 * <pre>
 * CompilationUnit:
 *     [ PackageDeclaration ]
 *         { ImportDeclaration }
 *         { TypeDeclaration | EnumDeclaration | AnnotationTypeDeclaration | ; }
 *
 * PackageDeclaration:
 *     [ Javadoc ] { Annotation } package Name ;
 *
 * ImportDeclaration:
 *     import [ static ] Name [ . * ] ;
 *
 * TypeDeclaration:
 *     ClassDeclaration
 *     InterfaceDeclaration
 *
 * ClassDeclaration:
 *     [ Javadoc ] { ExtendedModifier } class Identifier
 *         [ < TypeParameter { , TypeParameter } > ]
 *         [ extends Type ]
 *         [ implements Type { , Type } ]
 *         { { ClassBodyDeclaration | ; } }
 *
 * InterfaceDeclaration:
 *     [ Javadoc ] { ExtendedModifier } interface Identifier
 *         [ < TypeParameter { , TypeParameter } > ]
 *         [ extends Type { , Type } ]
 *         { { InterfaceBodyDeclaration | ; } }
 * </pre>
 */
public class JdtRecorder implements SourceFileRecorder {

    private static final Logger LOGGER = Logger.getLogger(JdtRecorder.class);

    private CompilationUnit compilationUnit;
    private Sequencer.Context context;
    private String sourceCode;

    protected String getSourceCode( final int startPosition,
                                    final int length ) {
        if (StringUtil.isBlank(this.sourceCode)) {
            return null;
        }

        return this.sourceCode.substring(startPosition, (startPosition + length));
    }

    protected String getTypeName( final Type type ) {
        if (type.isPrimitiveType()) {
            final PrimitiveType primitiveType = (PrimitiveType)type;
            return primitiveType.getPrimitiveTypeCode().toString();
        }

        if (type.isSimpleType()) {
            final SimpleType simpleType = (SimpleType)type;
            return simpleType.getName().getFullyQualifiedName();
        }

        if (type.isQualifiedType()) {
            final QualifiedType qualifiedType = (QualifiedType)type;
            return qualifiedType.getName().getFullyQualifiedName();
        }

        if (type.isParameterizedType()) {
            final ParameterizedType parameterizedType = (ParameterizedType)type;
            final StringBuilder result = new StringBuilder(getTypeName(parameterizedType.getType()));
            result.append('<');

            if (!parameterizedType.typeArguments().isEmpty()) {
                @SuppressWarnings( "unchecked" )
                final List<ParameterizedType> paramTypes = parameterizedType.typeArguments();
                boolean firstTime = true;

                for (final Type paramType : paramTypes) {
                    if (firstTime) {
                        firstTime = false;
                    } else {
                        result.append(", ");
                    }

                    result.append(getTypeName(paramType));
                }
            }

            result.append('>');
            return result.toString();
        }

        if (type.isArrayType()) {
            final ArrayType arrayType = (ArrayType)type;
            final Type elementType = arrayType.getElementType(); // the element type is never an array type

            if (elementType.isPrimitiveType()) {
                return ((PrimitiveType)elementType).getPrimitiveTypeCode().toString();

            }

            // can't be an array type
            if (elementType.isSimpleType()) {
                return ((SimpleType)elementType).getName().getFullyQualifiedName();
            }
        }

        if (type.isWildcardType()) {
            return "?";
        }

        return null;
    }

    protected String getVisibility( final int modifiers ) {
        if ((modifiers & Modifier.PUBLIC) != 0) {
            return Visibility.PUBLIC.getDescription();
        }

        if ((modifiers & Modifier.PROTECTED) != 0) {
            return Visibility.PROTECTED.getDescription();
        }

        if ((modifiers & Modifier.PRIVATE) != 0) {
            return Visibility.PRIVATE.getDescription();
        }

        return Visibility.PACKAGE.getDescription();
    }

    /**
     * <pre>
     * Annotation:
     *     NormalAnnotation
     *     MarkerAnnotation
     *     SingleMemberAnnotation
     *
     * NormalAnnotation:
     *     \@ TypeName ( [ MemberValuePair { , MemberValuePair } ] )
     *
     * MarkerAnnotation:
     *     \@ TypeName
     *
     * SingleMemberAnnotation:
     *     \@ TypeName ( Expression  )
     *
     * MemberValuePair:
     *     SimpleName = Expression
     *
     * </pre>
     *
     * @param annotation the {@link Annotation annotation} being recorded (cannot be <code>null</code>)
     * @param parentNode the parent {@link Node node} where the annotation will be created (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final Annotation annotation,
                           final Node parentNode ) throws Exception {
        final String name = annotation.getTypeName().getFullyQualifiedName();

        final Node annotationNode = parentNode.addNode(name, ClassFileSequencerLexicon.ANNOTATION);
        annotationNode.setProperty(ClassFileSequencerLexicon.NAME, name);

        if (annotation.isMarkerAnnotation()) {
            annotationNode.setProperty(ClassFileSequencerLexicon.ANNOTATION_TYPE,
                                       ClassFileSequencerLexicon.AnnotationType.MARKER.toString());
            LOGGER.debug("Marker annotation {0} created", name);
        } else if (annotation.isNormalAnnotation()) {
            annotationNode.setProperty(ClassFileSequencerLexicon.ANNOTATION_TYPE,
                                       ClassFileSequencerLexicon.AnnotationType.NORMAL.toString());
            @SuppressWarnings( "unchecked" )
            final List<MemberValuePair> entries = ((NormalAnnotation)annotation).values();

            if ((entries != null) && !entries.isEmpty()) {
                for (final MemberValuePair entry : entries) {
                    final String memberName = entry.getName().getFullyQualifiedName();
                    final Expression expression = entry.getValue();
                    recordAnnotationMember(memberName, expression, annotationNode);
                }
            }

            LOGGER.debug("Normal annotation {0} created", name);
        } else if (annotation.isSingleMemberAnnotation()) {
            annotationNode.setProperty(ClassFileSequencerLexicon.ANNOTATION_TYPE,
                                       ClassFileSequencerLexicon.AnnotationType.SINGLE_MEMBER.toString());
            final Expression expression = ((SingleMemberAnnotation)annotation).getValue();
            recordAnnotationMember(null, expression, annotationNode);
            LOGGER.debug("Single member annotation {0} created", name);
        } else {
            assert false;
            LOGGER.error(JavaFileI18n.unhandledAnnotationType, annotation.getClass().getName(), parentNode.getName());
        }

        recordSourceReference(annotation, annotationNode);
    }

    /**
     * <pre>
     * AnnotationTypeDeclaration:
     *     [ Javadoc ] { ExtendedModifier } @ interface Identifier
     *          { { AnnotationTypeBodyDeclaration | ; } }
     *
     * AnnotationTypeBodyDeclaration:
     *      AnnotationTypeMemberDeclaration
     *      FieldDeclaration
     *      TypeDeclaration
     *      EnumDeclaration
     *      AnnotationTypeDeclaration
     *
     * AnnotationTypeMemberDeclaration:
     *     [ Javadoc ] { ExtendedModifier }
     *         Type Identifier ( ) [ default Expression ] ;
     * </pre>
     *
     * @param annotationType the {@link AnnotationTypeDeclaration annotation type} being recorded (cannot be <code>null</code>)
     * @param outputNode the output node where the annotation type should be created (cannot be <code>null</code>)
     * @return the node representing the annotation type (never <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected Node record( final AnnotationTypeDeclaration annotationType,
                           final Node outputNode ) throws Exception {
        final String name = annotationType.getName().getFullyQualifiedName();
        final Node annotationTypeNode = outputNode.addNode(name, ClassFileSequencerLexicon.ANNOTATION_TYPE);
        annotationTypeNode.setProperty(ClassFileSequencerLexicon.NAME, name);
        annotationTypeNode.setProperty(ClassFileSequencerLexicon.VISIBILITY, getVisibility(annotationType.getModifiers()));
        annotationTypeNode.setProperty(ClassFileSequencerLexicon.SEQUENCED_DATE, this.context.getTimestamp());

        { // javadocs
            final Javadoc javadoc = annotationType.getJavadoc();

            if (javadoc != null) {
                record(javadoc, annotationTypeNode);
            }
        }

        { // annotations
            @SuppressWarnings( "unchecked" )
            final List<IExtendedModifier> modifiers = annotationType.modifiers();
            recordAnnotations(modifiers, annotationTypeNode);
        }

        { // body
            @SuppressWarnings( "unchecked" )
            final List<BodyDeclaration> body = annotationType.bodyDeclarations();

            if ((body != null) && !body.isEmpty()) {
                Node fieldsNode = null;
                Node membersNode = null;
                Node nestedTypesNode = null;

                for (final BodyDeclaration declaration : body) {
                    if (declaration instanceof AnnotationTypeMemberDeclaration) {
                        if (membersNode == null) {
                            membersNode = annotationTypeNode.addNode(ClassFileSequencerLexicon.ANNOTATION_TYPE_MEMBERS,
                                                                     ClassFileSequencerLexicon.ANNOTATION_TYPE_MEMBERS);
                        }

                        record((AnnotationTypeMemberDeclaration)declaration, membersNode);
                    } else if (declaration instanceof FieldDeclaration) {
                        if (fieldsNode == null) {
                            fieldsNode = annotationTypeNode.addNode(ClassFileSequencerLexicon.FIELDS,
                                                                    ClassFileSequencerLexicon.FIELDS);
                        }

                        record((FieldDeclaration)declaration, fieldsNode);
                    } else if (declaration instanceof AbstractTypeDeclaration) {
                        if (nestedTypesNode == null) {
                            nestedTypesNode = annotationTypeNode.addNode(ClassFileSequencerLexicon.NESTED_TYPES,
                                                                         ClassFileSequencerLexicon.NESTED_TYPES);
                        }

                        if (declaration instanceof TypeDeclaration) {
                            record((TypeDeclaration)declaration, nestedTypesNode);
                        } else if (declaration instanceof EnumDeclaration) {
                            record((EnumDeclaration)declaration, nestedTypesNode);
                        } else if (declaration instanceof AnnotationTypeDeclaration) {
                            record((AnnotationTypeDeclaration)declaration, nestedTypesNode);
                        } else {
                            assert false;
                            LOGGER.error(JavaFileI18n.unhandledAnnotationTypeBodyDeclarationType,
                                         declaration.getClass().getName(),
                                         annotationType.getName());
                        }
                    } else {
                        assert false;
                        LOGGER.error(JavaFileI18n.unhandledAnnotationTypeBodyDeclarationType,
                                     declaration.getClass().getName(),
                                     annotationType.getName());
                    }
                }
            }
        }

        recordSourceReference(annotationType, annotationTypeNode);
        return annotationTypeNode;
    }

    /**
     * <pre>
     * AnnotationTypeMemberDeclaration:
     *     [ Javadoc ] { ExtendedModifier }
     *         Type Identifier ( ) [ default Expression ] ;
     * </pre>
     *
     * @param annotationTypeMember the {@link AnnotationTypeMemberDeclaration annotation type member} being recorded (cannot be
     *        <code>null</code>)
     * @param parentNode the parent {@link Node node} where the annotation type members will be added (cannot be <code>null</code>
     *        )
     * @throws Exception if there is a problem
     */
    protected void record( final AnnotationTypeMemberDeclaration annotationTypeMember,
                           final Node parentNode ) throws Exception {
        final Node memberNode = parentNode.addNode(ClassFileSequencerLexicon.ANNOTATION_TYPE_MEMBER,
                                                   ClassFileSequencerLexicon.ANNOTATION_TYPE_MEMBER);
        memberNode.setProperty(ClassFileSequencerLexicon.NAME, annotationTypeMember.getName().getFullyQualifiedName());

        { // modifiers
            final int modifiers = annotationTypeMember.getModifiers();
            memberNode.setProperty(ClassFileSequencerLexicon.ABSTRACT, (modifiers & Modifier.ABSTRACT) != 0);
            memberNode.setProperty(ClassFileSequencerLexicon.VISIBILITY, getVisibility(modifiers));
        }

        { // javadocs
            final Javadoc javadoc = annotationTypeMember.getJavadoc();

            if (javadoc != null) {
                record(javadoc, memberNode);
            }
        }

        { // annotations
            @SuppressWarnings( "unchecked" )
            final List<IExtendedModifier> modifiers = annotationTypeMember.modifiers();
            recordAnnotations(modifiers, memberNode);
        }

        { // type
            final Type type = annotationTypeMember.getType();
            record(type, ClassFileSequencerLexicon.TYPE, memberNode);
        }

        { // default expression
            final Expression expression = annotationTypeMember.getDefault();

            if (expression != null) {
                recordExpression(expression, ClassFileSequencerLexicon.DEFAULT, memberNode);
            }
        }
    }

    /**
     * <pre>
     * Block:
     *     { { Statement } }
     * </pre>
     *
     * @param block the {@link Block block} being recorded (cannot be <code>null</code>)
     * @param blockNode the parent {@link Node node} where the statements will be added (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final Block block,
                           final Node blockNode ) throws Exception {
        if (block != null) {
            @SuppressWarnings( "unchecked" )
            final List<Statement> statements = block.statements();

            if ((statements != null) && !statements.isEmpty()) {
                for (final Statement statement : statements) {
                    // TODO handle each type of statement
                    final Node stmtNode = blockNode.addNode(ClassFileSequencerLexicon.STATEMENT,
                                                            ClassFileSequencerLexicon.STATEMENT);
                    stmtNode.setProperty(ClassFileSequencerLexicon.CONTENT, statement.toString());
                    recordSourceReference(statement, stmtNode);
                }
            }
        }
    }

    /**
     * <pre>
     * Comment:
     *     LineComment
     *     BlockComment
     *     Javadoc
     * </pre>
     *
     * @param comment the comment being recorded (cannot be <code>null</code>)
     * @param parentNode the {@link Node parent node} (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final Comment comment,
                           final Node parentNode ) throws Exception {
        Node commentNode = null;
        String commentType = null;

        if (comment.isDocComment()) {
            commentNode = parentNode.addNode(ClassFileSequencerLexicon.JAVADOC, ClassFileSequencerLexicon.JAVADOC);
        } else {
            commentNode = parentNode.addNode(ClassFileSequencerLexicon.COMMENT, ClassFileSequencerLexicon.COMMENT);

            if (comment.isBlockComment()) {
                commentType = ClassFileSequencerLexicon.CommentType.BLOCK.toString();
            } else if (comment.isLineComment()) {
                commentType = ClassFileSequencerLexicon.CommentType.LINE.toString();
            } else {
                assert false;
                LOGGER.error(JavaFileI18n.unhandledCommentType, comment.getClass().getName());
            }

            commentNode.setProperty(ClassFileSequencerLexicon.COMMENT_TYPE, commentType);
        }

        final String code = getSourceCode(comment.getStartPosition(), comment.getLength());

        if (!StringUtil.isBlank(code)) {
            commentNode.setProperty(ClassFileSequencerLexicon.COMMENT, code);
        }

        recordSourceReference(comment, commentNode);
    }

    /**
     * <pre>
     * CompilationUnit:
     *     [ PackageDeclaration ]
     *          { ImportDeclaration }
     *          { TypeDeclaration | EnumDeclaration | AnnotationTypeDeclaration | ; }
     * </pre>
     *
     * @param unit the {@link CompilationUnit compilation unit} being recorded (cannot be <code>null</code>)
     * @param compilationUnitNode the output node associated with the compilation unit (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final CompilationUnit unit,
                           final Node compilationUnitNode ) throws Exception {
        LOGGER.debug("recording unit comments");
        recordComments(unit, compilationUnitNode);

        LOGGER.debug("recording unit import nodes");
        recordImports(unit, compilationUnitNode);

        LOGGER.debug("recording unit compiler messages");
        recordCompilerMessages(unit, compilationUnitNode);

        LOGGER.debug("recording unit package nodes");
        final Node pkgNode = recordPackage(unit, compilationUnitNode);

        LOGGER.debug("recording unit type nodes");
        recordTypes(unit, compilationUnitNode, pkgNode);

        LOGGER.debug("recording unit source reference");
        recordSourceReference(unit, compilationUnitNode);

        compilationUnitNode.setProperty(ClassFileSequencerLexicon.SEQUENCED_DATE, this.context.getTimestamp());
    }

    /**
     * {@inheritDoc}
     *
     * @see org.modeshape.sequencer.javafile.SourceFileRecorder#record(org.modeshape.jcr.api.sequencer.Sequencer.Context,
     *      java.io.InputStream, long, java.lang.String, javax.jcr.Node)
     */
    @Override
    public void record( final Context context,
                        final InputStream inputStream,
                        final long length,
                        final String encoding,
                        final Node outputNode ) throws Exception {
        final char[] sourceCode = JavaMetadataUtil.getJavaSourceFromTheInputStream(inputStream, length, encoding);
        record(context, sourceCode, outputNode);
    }

    /**
     * <pre>
     * EnumConstantDeclaration:
     *     [ Javadoc ] { ExtendedModifier } Identifier
     *         [ ( [ Expression { , Expression } ] ) ]
     *         [ AnonymousClassDeclaration ]
     * </pre>
     *
     * @param enumConstant the enum constant being processed (cannot be <code>null</code>)
     * @param parentNode the {@link Node node} where the enum constant node will be created (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final EnumConstantDeclaration enumConstant,
                           final Node parentNode ) throws Exception {
        final String name = enumConstant.getName().getIdentifier();
        final Node constantNode = parentNode.addNode(name, ClassFileSequencerLexicon.ENUM_CONSTANT);

        { // javadocs
            final Javadoc javadoc = enumConstant.getJavadoc();

            if (javadoc != null) {
                record(javadoc, constantNode);
            }
        }

        { // no modifiers but can have annotations
            @SuppressWarnings( "unchecked" )
            final List<IExtendedModifier> modifiers = enumConstant.modifiers();
            recordAnnotations(modifiers, constantNode);
        }

        { // args
            @SuppressWarnings( "unchecked" )
            final List<Expression> args = enumConstant.arguments();

            if ((args != null) && !args.isEmpty()) {
                final Node containerNode = constantNode.addNode(ClassFileSequencerLexicon.ARGUMENTS,
                                                                ClassFileSequencerLexicon.ARGUMENTS);

                for (final Expression arg : args) {
                    recordExpression(arg, ClassFileSequencerLexicon.ARGUMENT, containerNode);
                }
            }
        }

        // anonymous classes
        final AnonymousClassDeclaration acd = enumConstant.getAnonymousClassDeclaration();

        if (acd != null) {
            recordBodyDeclarations(acd, constantNode);
        }

        recordSourceReference(enumConstant, constantNode);
    }

    /**
     * <pre>
     * EnumDeclaration:
     * [ Javadoc ] { ExtendedModifier } enum Identifier
     *     [ implements Type { , Type } ]
     *     {
     *     [ EnumConstantDeclaration { , EnumConstantDeclaration } ] [ , ]
     *     [ ; { ClassBodyDeclaration | ; } ]
     *     }
     * </pre>
     *
     * @param enumType the {@link EnumDeclaration enum} being recorded (cannot be <code>null</code>)
     * @param parentNode the parent {@link Node node} (cannot be <code>null</code>)
     * @return the node representing the enum being recorded (never <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected Node record( final EnumDeclaration enumType,
                           final Node parentNode ) throws Exception {
        final String name = enumType.getName().getFullyQualifiedName();
        final Node enumNode = parentNode.addNode(name, ClassFileSequencerLexicon.ENUM);
        enumNode.setProperty(ClassFileSequencerLexicon.NAME, name);
        enumNode.setProperty(ClassFileSequencerLexicon.SEQUENCED_DATE, this.context.getTimestamp());
        enumNode.setProperty(ClassFileSequencerLexicon.INTERFACE, false);

        { // javadocs
            final Javadoc javadoc = enumType.getJavadoc();

            if (javadoc != null) {
                record(javadoc, enumNode);
            }
        }

        { // modifiers
            final int modifiers = enumType.getModifiers();

            enumNode.setProperty(ClassFileSequencerLexicon.ABSTRACT, (modifiers & Modifier.ABSTRACT) != 0);
            enumNode.setProperty(ClassFileSequencerLexicon.FINAL, (modifiers & Modifier.FINAL) != 0);
            enumNode.setProperty(ClassFileSequencerLexicon.STATIC, (modifiers & Modifier.STATIC) != 0);
            enumNode.setProperty(ClassFileSequencerLexicon.STRICT_FP, (modifiers & Modifier.STRICTFP) != 0);
            enumNode.setProperty(ClassFileSequencerLexicon.VISIBILITY, getVisibility(modifiers));
        }

        { // annotations
            @SuppressWarnings( "unchecked" )
            final List<IExtendedModifier> modifiers = enumType.modifiers();
            recordAnnotations(modifiers, enumNode);
        }

        { // implements
            @SuppressWarnings( "unchecked" )
            final List<Type> interfaces = enumType.superInterfaceTypes();

            if ((interfaces != null) && !interfaces.isEmpty()) {
                final String[] interfaceNames = new String[interfaces.size()];
                final Node containerNode = enumNode.addNode(ClassFileSequencerLexicon.IMPLEMENTS, ClassFileSequencerLexicon.TYPES);
                int i = 0;

                for (final Type superInterfaceType : interfaces) {
                    interfaceNames[i] = getTypeName(superInterfaceType);
                    record(superInterfaceType, ClassFileSequencerLexicon.INTERFACE, containerNode);
                    ++i;
                }

                enumNode.setProperty(ClassFileSequencerLexicon.INTERFACES, interfaceNames);
            }
        }

        { // enum constants
            @SuppressWarnings( "unchecked" )
            final List<EnumConstantDeclaration> enumValues = enumType.enumConstants();

            if ((enumValues != null) && !enumValues.isEmpty()) {
                final String[] values = new String[enumValues.size()];
                final Node containerNode = enumNode.addNode(ClassFileSequencerLexicon.ENUM_CONSTANTS,
                                                            ClassFileSequencerLexicon.ENUM_CONSTANTS);
                int i = 0;

                for (final EnumConstantDeclaration enumConstant : enumValues) {
                    values[i++] = enumConstant.getName().getFullyQualifiedName();
                    record(enumConstant, containerNode);
                }

                enumNode.setProperty(ClassFileSequencerLexicon.ENUM_VALUES, values);
            }
        }

        recordBodyDeclarations(enumType, enumNode);
        recordSourceReference(enumType, enumNode);
        return enumNode;
    }

    /**
     * <pre>
     * FieldDeclaration:
     *      [Javadoc] { ExtendedModifier } Type VariableDeclarationFragment
     *           { , VariableDeclarationFragment } ;
     *
     * VariableDeclarationFragment:
     *     Identifier { [] } [ = Expression ]
     * </pre>
     *
     * A field container node will be created if one does not exist under <code>node</node>.
     *
     * @param field the {@link FieldDeclaration field} being recorded {cannot be <code>null</code>
     * @param parentNode the parent {@link Node node} (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final FieldDeclaration field,
                           final Node parentNode ) throws Exception {
        @SuppressWarnings( "unchecked" )
        final List<VariableDeclarationFragment> frags = field.fragments();
        final String name = frags.get(0).getName().getFullyQualifiedName();

        final Node fieldNode = parentNode.addNode(name, ClassFileSequencerLexicon.FIELD);
        fieldNode.setProperty(ClassFileSequencerLexicon.NAME, name);

        { // javadocs
            final Javadoc javadoc = field.getJavadoc();

            if (javadoc != null) {
                record(javadoc, fieldNode);
            }
        }

        { // type
            final Type type = field.getType();
            final String typeName = getTypeName(type);
            fieldNode.setProperty(ClassFileSequencerLexicon.TYPE_CLASS_NAME, typeName);
            record(type, ClassFileSequencerLexicon.TYPE, fieldNode);
        }

        { // modifiers
            final int modifiers = field.getModifiers();

            fieldNode.setProperty(ClassFileSequencerLexicon.FINAL, (modifiers & Modifier.FINAL) != 0);
            fieldNode.setProperty(ClassFileSequencerLexicon.STATIC, (modifiers & Modifier.STATIC) != 0);
            fieldNode.setProperty(ClassFileSequencerLexicon.TRANSIENT, (modifiers & Modifier.TRANSIENT) != 0);
            fieldNode.setProperty(ClassFileSequencerLexicon.VISIBILITY, getVisibility(modifiers));
            fieldNode.setProperty(ClassFileSequencerLexicon.VOLATILE, (modifiers & Modifier.VOLATILE) != 0);
        }

        { // annotations
            @SuppressWarnings( "unchecked" )
            final List<IExtendedModifier> modifiers = field.modifiers();
            recordAnnotations(modifiers, fieldNode);
        }

        { // fragments
            @SuppressWarnings( "unchecked" )
            final List<VariableDeclarationFragment> fragments = field.fragments();

            if ((fragments != null) && !fragments.isEmpty()) {
                for (final VariableDeclarationFragment var : fragments) {
                    final Expression initializer = var.getInitializer();

                    if (initializer != null) {
                        recordExpression(initializer, ClassFileSequencerLexicon.INITIALIZER, fieldNode);
                    }
                }
            }
        }

        recordSourceReference(field, fieldNode);
    }

    /**
     * <pre>
     * Initializer:
     *     [ static ] Block
     *
     * Block:
     *     { { Statement } }
     * </pre>
     *
     * @param initializer the {@link Initializer initializer} being recorded (cannot be <code>null</code>)
     * @param nodeName the name of the node being created that represents the initializer (cannot be <code>null</code> or empty)
     * @param parentNode the parent {@link Node node} (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final Initializer initializer,
                           final String nodeName,
                           final Node parentNode ) throws Exception {
        final Block block = initializer.getBody();

        if (block != null) {
            @SuppressWarnings( "unchecked" )
            final List<Statement> statements = block.statements();

            if ((statements != null) && !statements.isEmpty()) {
                final Node initializerNode = parentNode.addNode(nodeName, ClassFileSequencerLexicon.STATEMENTS);
                record(block, initializerNode);
            }
        }
    }

    /**
     * <pre>
     * MethodDeclaration:
     *     [ Javadoc ] { ExtendedModifier }
     *          [ < TypeParameter { , TypeParameter } > ]
     *     ( Type | void ) Identifier (
     *     [ FormalParameter
     *          { , FormalParameter } ] ) {[ ] }
     *     [ throws TypeName { , TypeName } ] ( Block | ; )
     *
     * ConstructorDeclaration:
     *     [ Javadoc ] { ExtendedModifier }
     *          [ < TypeParameter { , TypeParameter } > ]
     *     Identifier (
     *         [ FormalParameter
     *             { , FormalParameter } ] )
     *     [throws TypeName { , TypeName } ] Block
     *
     * </pre>
     *
     * @param method the {@link MethodDeclaration method} being recorded (cannot be <code>null</code>)
     * @param parentNode the parent {@link Node node} (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final MethodDeclaration method,
                           final Node parentNode ) throws Exception {
        final String name = method.getName().getFullyQualifiedName();
        final Node methodNode = parentNode.addNode(name, ClassFileSequencerLexicon.METHOD);
        methodNode.setProperty(ClassFileSequencerLexicon.NAME, name);

        { // javadocs
            final Javadoc javadoc = method.getJavadoc();

            if (javadoc != null) {
                record(javadoc, methodNode);
            }
        }

        { // type parameters
            @SuppressWarnings( "unchecked" )
            final List<TypeParameter> typeParams = method.typeParameters();

            if ((typeParams != null) && !typeParams.isEmpty()) {
                final Node containerNode = methodNode.addNode(ClassFileSequencerLexicon.TYPE_PARAMETERS,
                                                              ClassFileSequencerLexicon.TYPE_PARAMETERS);

                for (final TypeParameter param : typeParams) {
                    record(param, containerNode);
                }
            }
        }

        { // modifiers
            final int modifiers = method.getModifiers();

            methodNode.setProperty(ClassFileSequencerLexicon.ABSTRACT, (modifiers & Modifier.ABSTRACT) != 0);
            methodNode.setProperty(ClassFileSequencerLexicon.FINAL, (modifiers & Modifier.FINAL) != 0);
            methodNode.setProperty(ClassFileSequencerLexicon.NATIVE, (modifiers & Modifier.NATIVE) != 0);
            methodNode.setProperty(ClassFileSequencerLexicon.STATIC, (modifiers & Modifier.STATIC) != 0);
            methodNode.setProperty(ClassFileSequencerLexicon.STRICT_FP, (modifiers & Modifier.STRICTFP) != 0);
            methodNode.setProperty(ClassFileSequencerLexicon.SYNCHRONIZED, (modifiers & Modifier.SYNCHRONIZED) != 0);
            methodNode.setProperty(ClassFileSequencerLexicon.VISIBILITY, getVisibility(modifiers));
        }

        { // annotations
            @SuppressWarnings( "unchecked" )
            final List<IExtendedModifier> modifiers = method.modifiers();
            recordAnnotations(modifiers, methodNode);
        }

        { // parameters
            @SuppressWarnings( "unchecked" )
            final List<SingleVariableDeclaration> params = method.parameters();

            if ((params != null) && !params.isEmpty()) {
                final Node containerNode = methodNode.addNode(ClassFileSequencerLexicon.METHOD_PARAMETERS,
                                                              ClassFileSequencerLexicon.PARAMETERS);

                for (final SingleVariableDeclaration param : params) {
                    record(param, containerNode);
                }
            }
        }

        { // return type
            if (method.isConstructor()) {
                methodNode.setProperty(ClassFileSequencerLexicon.RETURN_TYPE_CLASS_NAME, Void.TYPE.getCanonicalName());
            } else {
                final Type returnType = method.getReturnType2();
                methodNode.setProperty(ClassFileSequencerLexicon.RETURN_TYPE_CLASS_NAME, getTypeName(returnType));
                record(returnType, ClassFileSequencerLexicon.RETURN_TYPE, methodNode);
            }
        }

        { // thrown exceptions
            @SuppressWarnings( "unchecked" )
            final List<Name> errors = method.thrownExceptions();

            if ((errors != null) && !errors.isEmpty()) {
                final String[] errorNames = new String[errors.size()];
                int i = 0;

                for (final Name error : errors) {
                    errorNames[i++] = error.getFullyQualifiedName();
                }

                methodNode.setProperty(ClassFileSequencerLexicon.THROWN_EXCEPTIONS, errorNames);
            }
        }

        { // body
            final Block body = method.getBody();

            if ((body != null) && (body.statements() != null) && !body.statements().isEmpty()) {
                final Node bodyNode = methodNode.addNode(ClassFileSequencerLexicon.BODY, ClassFileSequencerLexicon.STATEMENTS);
                record(body, bodyNode);
            }
        }

        recordSourceReference(method, methodNode);
    }

    /**
     * Convert the compilation unit into JCR nodes.
     *
     * @param context the sequencer context
     * @param sourceCode the source code being recorded (can be <code>null</code> if there is no source code)
     * @param outputNode the {@link Node node} where the output will be saved (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final Sequencer.Context context,
                           final char[] sourceCode,
                           final Node outputNode ) throws Exception {
        if ((sourceCode == null) || (sourceCode.length == 0)) {
            LOGGER.debug("No source code was found for output node {0}", outputNode.getName());
            return;
        }

        this.context = context;
        this.sourceCode = new String(sourceCode);
        this.compilationUnit = (CompilationUnit)CompilationUnitParser.runJLS3Conversion(sourceCode, true);

        outputNode.addMixin(ClassFileSequencerLexicon.COMPILATION_UNIT);
        record(this.compilationUnit, outputNode);
    }

    /**
     * <pre>
     * SingleVariableDeclaration:
     *     { ExtendedModifier } Type [ ... ] Identifier { [] } [ = Expression ]
     * </pre>
     *
     * @param variable the {@link SingleVariableDeclaration variable} being recorded (cannot be <code>null</code>)
     * @param parentNode the parent {@link Node node} where the variable is being recorded (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final SingleVariableDeclaration variable,
                           final Node parentNode ) throws Exception {
        final String name = variable.getName().getFullyQualifiedName();
        final Node paramNode = parentNode.addNode(name, ClassFileSequencerLexicon.PARAMETER);
        paramNode.setProperty(ClassFileSequencerLexicon.NAME, name);
        paramNode.setProperty(ClassFileSequencerLexicon.FINAL, (variable.getModifiers() & Modifier.FINAL) != 0);
        paramNode.setProperty(ClassFileSequencerLexicon.VARARGS, variable.isVarargs());

        { // type
            final Type type = variable.getType();
            final String typeName = getTypeName(type);
            paramNode.setProperty(ClassFileSequencerLexicon.TYPE_CLASS_NAME, typeName);
            record(type, ClassFileSequencerLexicon.TYPE, paramNode);
        }

        { // initializer
            final Expression initializer = variable.getInitializer();

            if (initializer != null) {
                recordExpression(initializer, ClassFileSequencerLexicon.INITIALIZER, paramNode);
            }
        }

        { // annotations
            @SuppressWarnings( "unchecked" )
            final List<IExtendedModifier> modifiers = variable.modifiers();
            recordAnnotations(modifiers, paramNode);
        }

        recordSourceReference(variable, paramNode);
    }

    /**
     * <pre>
     * Type:
     *     PrimitiveType
     *     ArrayType
     *     SimpleType
     *     QualifiedType
     *     ParameterizedType
     *     WildcardType
     *
     * PrimitiveType:
     *     byte
     *     short
     *     char
     *     int
     *     long
     *     float
     *     double
     *     boolean
     *     void
     *
     * ArrayType:
     *     Type [ ]
     *
     * SimpleType:
     *     TypeName
     *
     * ParameterizedType:
     *     Type < Type { , Type } >
     *
     * QualifiedType:
     *     Type . SimpleName
     *
     * WildcardType:
     *     ? [ ( extends | super) Type ]
     * </pre>
     *
     * @param type the type {@link Type type} being recorded (cannot be <code>null</code>)
     * @param typeNodeName the name of the type node being recorded (cannot be <code>null</code> or empty)
     * @param parentNode the parent {@link Node node} where the type will be recorded (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final Type type,
                           final String typeNodeName,
                           final Node parentNode ) throws Exception {
        if (type.isSimpleType()) {
            final Node typeNode = parentNode.addNode(typeNodeName, ClassFileSequencerLexicon.SIMPLE_TYPE);
            typeNode.setProperty(ClassFileSequencerLexicon.TYPE_CLASS_NAME, getTypeName(type));
            LOGGER.debug("Simple type created at '{0}'", typeNode.getPath());
        } else if (type.isPrimitiveType()) {
            final Node typeNode = parentNode.addNode(typeNodeName, ClassFileSequencerLexicon.PRIMITIVE_TYPE);
            typeNode.setProperty(ClassFileSequencerLexicon.TYPE_CLASS_NAME, getTypeName(type));
            LOGGER.debug("Primitive type created at '{0}'", typeNode.getPath());
        } else if (type.isArrayType()) {
            final Node typeNode = parentNode.addNode(typeNodeName, ClassFileSequencerLexicon.ARRAY_TYPE);
            typeNode.setProperty(ClassFileSequencerLexicon.TYPE_CLASS_NAME, getTypeName(type));

            final ArrayType arrayType = ((ArrayType)type);
            typeNode.setProperty(ClassFileSequencerLexicon.DIMENSIONS, arrayType.getDimensions());

            final Type componentType = arrayType.getComponentType();
            record(componentType, ClassFileSequencerLexicon.COMPONENT_TYPE, typeNode);
            LOGGER.debug("Array type created at '{0}'", typeNode.getPath());
        } else if (type.isParameterizedType()) {
            final Node typeNode = parentNode.addNode(typeNodeName, ClassFileSequencerLexicon.PARAMETERIZED_TYPE);
            typeNode.setProperty(ClassFileSequencerLexicon.TYPE_CLASS_NAME, getTypeName(type));

            final ParameterizedType paramType = (ParameterizedType)type;
            final Type baseType = paramType.getType();
            record(baseType, ClassFileSequencerLexicon.BASE_TYPE, typeNode);

            @SuppressWarnings( "unchecked" )
            final List<Type> arguments = ((ParameterizedType)type).typeArguments();

            if ((arguments != null) && !arguments.isEmpty()) {
                final Node containerNode = typeNode.addNode(ClassFileSequencerLexicon.ARGUMENTS, ClassFileSequencerLexicon.TYPES);

                for (final Type arg : arguments) {
                    record(arg, ClassFileSequencerLexicon.ARGUMENT, containerNode);
                }
            }

            LOGGER.debug("Parameterized type created at '{0}'", typeNode.getPath());
        } else if (type.isQualifiedType()) {
            final Node typeNode = parentNode.addNode(typeNodeName, ClassFileSequencerLexicon.QUALIFIED_TYPE);
            typeNode.setProperty(ClassFileSequencerLexicon.TYPE_CLASS_NAME, getTypeName(type));

            final QualifiedType qualifiedType = (QualifiedType)type;
            record(qualifiedType.getQualifier(), ClassFileSequencerLexicon.QUALIFIER, typeNode);
            LOGGER.debug("Qualified type created at '{0}'", typeNode.getPath());
        } else if (type.isWildcardType()) {
            final Node typeNode = parentNode.addNode("?", ClassFileSequencerLexicon.WILDCARD_TYPE);
            typeNode.setProperty(ClassFileSequencerLexicon.TYPE_CLASS_NAME, getTypeName(type));

            final WildcardType wildcardType = (WildcardType)type;
            final String bound = wildcardType.isUpperBound() ? ClassFileSequencerLexicon.WildcardTypeBound.UPPER.toString() : ClassFileSequencerLexicon.WildcardTypeBound.LOWER.toString();
            typeNode.setProperty(ClassFileSequencerLexicon.BOUND_TYPE, bound);

            if (wildcardType.getBound() != null) {
                record(wildcardType.getBound(), ClassFileSequencerLexicon.BOUND, typeNode);
            }

            LOGGER.debug("Wildcard type created at '{0}'", typeNode.getPath());
        } else {
            assert false;
            LOGGER.error(JavaFileI18n.unhandledType, type.getClass().getName(), typeNodeName);
        }
    }

    /**
     * <pre>
     * TypeDeclaration:
     *     ClassDeclaration
     *     InterfaceDeclaration
     *
     * ClassDeclaration:
     *     [ Javadoc ] { ExtendedModifier } class Identifier
     *     [ < TypeParameter { , TypeParameter } > ]
     *     [ extends Type ]
     *     [ implements Type { , Type } ]
     *     { { ClassBodyDeclaration | ; } }
     *
     * InterfaceDeclaration:
     *     [ Javadoc ] { ExtendedModifier } interface Identifier
     *     [ < TypeParameter { , TypeParameter } > ]
     *     [ extends Type { , Type } ]
     *     { { InterfaceBodyDeclaration | ; } }
     * </pre>
     *
     * @param type the {@link TypeDeclaration type} being recorded (cannot be <code>null</code>)
     * @param parentNode the parent {@link Node node} where the new type will be created (cannot be <code>null</code>)
     * @return the node representing the type being recorded (never <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected Node record( final TypeDeclaration type,
                           final Node parentNode ) throws Exception {
        final String name = type.getName().getFullyQualifiedName();

        final Node typeNode = parentNode.addNode(name, ClassFileSequencerLexicon.CLASS);
        typeNode.setProperty(ClassFileSequencerLexicon.NAME, name);
        typeNode.setProperty(ClassFileSequencerLexicon.SEQUENCED_DATE, this.context.getTimestamp());

        final boolean isInterface = type.isInterface();
        typeNode.setProperty(ClassFileSequencerLexicon.INTERFACE, isInterface);

        // extends and implements
        @SuppressWarnings( "unchecked" )
        final List<Type> interfaces = type.superInterfaceTypes();

        { // extends
            if (isInterface) {
                if ((interfaces != null) && !interfaces.isEmpty()) {
                    final Node extendsNode = typeNode.addNode(ClassFileSequencerLexicon.EXTENDS, ClassFileSequencerLexicon.TYPES);

                    for (final Type interfaceType : interfaces) {
                        record(interfaceType, ClassFileSequencerLexicon.INTERFACE, extendsNode);
                    }
                }
            } else {
                final Type superType = type.getSuperclassType();
                String superTypeName = null;

                if (superType == null) {
                    superTypeName = Object.class.getCanonicalName();
                } else {
                    superTypeName = getTypeName(superType);
                }

                assert !StringUtil.isBlank(superTypeName);
                typeNode.setProperty(ClassFileSequencerLexicon.SUPER_CLASS_NAME, superTypeName);

                if (superType != null) {
                    final Node extendsNode = typeNode.addNode(ClassFileSequencerLexicon.EXTENDS, ClassFileSequencerLexicon.TYPES);
                    record(superType, getTypeName(superType), extendsNode);
                }
            }
        }

        { // implements
            if (!isInterface && (interfaces != null) && !interfaces.isEmpty()) {
                final Node implementsNode = typeNode.addNode(ClassFileSequencerLexicon.IMPLEMENTS,
                                                             ClassFileSequencerLexicon.TYPES);
                final String[] interfaceNames = new String[interfaces.size()];

                for (int i = 0, size = interfaces.size(); i < size; ++i) {
                    final Type interfaceType = interfaces.get(i);
                    interfaceNames[i] = getTypeName(interfaceType);
                    record(interfaceType, interfaceNames[i], implementsNode);
                }

                typeNode.setProperty(ClassFileSequencerLexicon.INTERFACES, interfaceNames);
            }
        }

        { // javadocs
            final Javadoc javadoc = type.getJavadoc();

            if (javadoc != null) {
                record(javadoc, typeNode);
            }
        }

        { // modifiers
            final int modifiers = type.getModifiers();

            typeNode.setProperty(ClassFileSequencerLexicon.ABSTRACT, (modifiers & Modifier.ABSTRACT) != 0);
            typeNode.setProperty(ClassFileSequencerLexicon.FINAL, (modifiers & Modifier.FINAL) != 0);
            typeNode.setProperty(ClassFileSequencerLexicon.STATIC, (modifiers & Modifier.STATIC) != 0);
            typeNode.setProperty(ClassFileSequencerLexicon.STRICT_FP, (modifiers & Modifier.STRICTFP) != 0);
            typeNode.setProperty(ClassFileSequencerLexicon.VISIBILITY, getVisibility(modifiers));
        }

        { // annotations
            @SuppressWarnings( "unchecked" )
            final List<IExtendedModifier> modifiers = type.modifiers();
            recordAnnotations(modifiers, typeNode);
        }

        { // type parameters
            @SuppressWarnings( "unchecked" )
            final List<TypeParameter> typeParams = type.typeParameters();

            if ((typeParams != null) && !typeParams.isEmpty()) {
                final Node containerNode = typeNode.addNode(ClassFileSequencerLexicon.TYPE_PARAMETERS,
                                                            ClassFileSequencerLexicon.TYPE_PARAMETERS);

                for (final TypeParameter param : typeParams) {
                    record(param, containerNode);
                }
            }
        }

        recordBodyDeclarations(type, typeNode);
        recordSourceReference(type, typeNode);
        return typeNode;
    }

    /**
     * <pre>
     * TypeParameter:
     *     TypeVariable [ extends Type { & Type } ]
     * </pre>
     *
     * @param param the {@link TypeParameter type parameter} being recorded (cannot be <code>null</code>)
     * @param parentNode the parent {@link Node node} where the type parameter will be recorded (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void record( final TypeParameter param,
                           final Node parentNode ) throws Exception {
        final String paramName = param.getName().getFullyQualifiedName();
        final Node paramNode = parentNode.addNode(paramName, ClassFileSequencerLexicon.TYPE_PARAMETER);

        @SuppressWarnings( "unchecked" )
        final List<Type> bounds = param.typeBounds();

        if ((bounds != null) && !bounds.isEmpty()) {
            final Node containerNode = paramNode.addNode(ClassFileSequencerLexicon.BOUNDS, ClassFileSequencerLexicon.TYPES);

            for (final Type bound : bounds) {
                record(bound, getTypeName(bound), containerNode);
            }
        }

        recordSourceReference(param, paramNode);
    }

    protected void recordAnnotationMember( final String memberName,
                                           final Expression expression,
                                           final Node parentNode ) throws Exception {
        final String name = (StringUtil.isBlank(memberName) ? "default" : memberName);
        final Node node = parentNode.addNode(name, ClassFileSequencerLexicon.ANNOTATION_MEMBER);
        node.setProperty(ClassFileSequencerLexicon.NAME, name);

        String value = null;

        if (expression instanceof StringLiteral) {
            value = ((StringLiteral)expression).getLiteralValue();
        } else if (expression instanceof Name) {
            value = ((Name)expression).getFullyQualifiedName();
        } else if (expression instanceof BooleanLiteral) {
            value = Boolean.toString(((BooleanLiteral)expression).booleanValue());
        } else if (expression instanceof CharacterLiteral) {
            value = Character.toString(((CharacterLiteral)expression).charValue());
        } else {
            value = expression.toString();
        }

        node.setProperty(ClassFileSequencerLexicon.VALUE, value);
        recordExpression(expression, name, node);
    }

    protected void recordAnnotations( final List<IExtendedModifier> extendedModifiers,
                                      final Node node ) throws Exception {
        if ((extendedModifiers != null) && !extendedModifiers.isEmpty()) {
            Node containerNode = null;

            for (final IExtendedModifier modifier : extendedModifiers) {
                if (modifier.isAnnotation()) {
                    if (containerNode == null) {
                        containerNode = node.addNode(ClassFileSequencerLexicon.ANNOTATIONS, ClassFileSequencerLexicon.ANNOTATIONS);
                    }

                    record((Annotation)modifier, containerNode);
                }
            }
        }
    }

    protected void recordBodyDeclarations( final AbstractTypeDeclaration type,
                                           final Node typeNode ) throws Exception {
        Node constructorsContainer = null;
        Node fieldsContainer = null;
        Node methodsContainer = null;
        Node nestedTypesContainer = null;

        for (final Object bodyDeclaration : type.bodyDeclarations()) {
            if (bodyDeclaration instanceof FieldDeclaration) {
                if (fieldsContainer == null) {
                    fieldsContainer = typeNode.addNode(ClassFileSequencerLexicon.FIELDS, ClassFileSequencerLexicon.FIELDS);
                }

                record((FieldDeclaration)bodyDeclaration, fieldsContainer);
            } else if (bodyDeclaration instanceof MethodDeclaration) {
                final MethodDeclaration method = (MethodDeclaration)bodyDeclaration;

                if (method.isConstructor()) {
                    if (constructorsContainer == null) {
                        constructorsContainer = typeNode.addNode(ClassFileSequencerLexicon.CONSTRUCTORS,
                                                                 ClassFileSequencerLexicon.CONSTRUCTORS);
                    }

                    record(method, constructorsContainer);
                } else {
                    if (methodsContainer == null) {
                        methodsContainer = typeNode.addNode(ClassFileSequencerLexicon.METHODS, ClassFileSequencerLexicon.METHODS);
                    }

                    record(method, methodsContainer);
                }
            } else if (bodyDeclaration instanceof TypeDeclaration) {
                if (nestedTypesContainer == null) {
                    nestedTypesContainer = typeNode.addNode(ClassFileSequencerLexicon.NESTED_TYPES,
                                                            ClassFileSequencerLexicon.NESTED_TYPES);
                }

                record((TypeDeclaration)bodyDeclaration, nestedTypesContainer);
            } else if (bodyDeclaration instanceof EnumDeclaration) {
                if (nestedTypesContainer == null) {
                    nestedTypesContainer = typeNode.addNode(ClassFileSequencerLexicon.NESTED_TYPES,
                                                            ClassFileSequencerLexicon.NESTED_TYPES);
                }

                record((EnumDeclaration)bodyDeclaration, nestedTypesContainer);
            } else if (bodyDeclaration instanceof Initializer) {
                record(((Initializer)bodyDeclaration), ClassFileSequencerLexicon.INITIALIZER, typeNode);
            } else {
                assert false;
                LOGGER.error(JavaFileI18n.unhandledBodyDeclarationType, bodyDeclaration.getClass().getName());
            }
        }
    }

    protected void recordBodyDeclarations( final AnonymousClassDeclaration anonClass,
                                           final Node enumConstantNode ) throws Exception {
        Node fieldsContainer = null;
        Node methodsContainer = null;
        Node nestedTypesContainer = null;

        for (final Object bodyDeclaration : anonClass.bodyDeclarations()) {
            if (bodyDeclaration instanceof FieldDeclaration) {
                if (fieldsContainer == null) {
                    fieldsContainer = enumConstantNode.addNode(ClassFileSequencerLexicon.FIELDS, ClassFileSequencerLexicon.FIELDS);
                }

                record((FieldDeclaration)bodyDeclaration, fieldsContainer);
            } else if (bodyDeclaration instanceof MethodDeclaration) {
                if (methodsContainer == null) {
                    methodsContainer = enumConstantNode.addNode(ClassFileSequencerLexicon.METHODS,
                                                                ClassFileSequencerLexicon.METHODS);
                }

                record((MethodDeclaration)bodyDeclaration, methodsContainer);
            } else if (bodyDeclaration instanceof TypeDeclaration) {
                if (nestedTypesContainer == null) {
                    nestedTypesContainer = enumConstantNode.addNode(ClassFileSequencerLexicon.NESTED_TYPES,
                                                                    ClassFileSequencerLexicon.NESTED_TYPES);
                }

                record((TypeDeclaration)bodyDeclaration, nestedTypesContainer);
            } else {
                assert false;
                LOGGER.error(JavaFileI18n.unhandledBodyDeclarationType, bodyDeclaration.getClass().getName());
            }
        }
    }

    /**
     * <pre>
     * Comment:
     *     LineComment
     *     BlockComment
     *     Javadoc
     * </pre>
     *
     * @param compilationUnit the {@link CompilationUnit compilation unit} being recorded (cannot be <code>null</code>)
     * @param outputNode the parent {@link Node node} (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void recordComments( final CompilationUnit compilationUnit,
                                   final Node outputNode ) throws Exception {
        @SuppressWarnings( "unchecked" )
        final List<Comment> comments = compilationUnit.getCommentList();

        if ((comments != null) && !comments.isEmpty()) {
            final Node containerNode = outputNode.addNode(ClassFileSequencerLexicon.COMMENTS, ClassFileSequencerLexicon.COMMENTS);

            for (final Comment comment : comments) {
                // javadocs are stored with the object they pertain to
                if (!comment.isDocComment()) {
                    record(comment, containerNode);
                }
            }
        }
    }

    protected void recordCompilerMessages( final CompilationUnit unit,
                                           final Node parentNode ) throws Exception {
        final Message[] messages = unit.getMessages();

        if ((messages != null) && (messages.length != 0)) {
            final Node containerNode = parentNode.addNode(ClassFileSequencerLexicon.MESSAGES, ClassFileSequencerLexicon.MESSAGES);

            for (final Message message : messages) {
                final Node messageNode = containerNode.addNode(ClassFileSequencerLexicon.MESSAGE,
                                                               ClassFileSequencerLexicon.MESSAGE);
                messageNode.setProperty(ClassFileSequencerLexicon.MESSAGE, message.getMessage());
                messageNode.setProperty(ClassFileSequencerLexicon.START_POSITION, message.getStartPosition());
                messageNode.setProperty(ClassFileSequencerLexicon.LENGTH, message.getLength());
            }
        }
    }

    /**
     * <pre>
     * Expression:
     *
     * Annotation,
     * ArrayAccess,
     * ArrayCreation,
     * ArrayInitializer,
     * Assignment,
     * BooleanLiteral,
     * CastExpression,
     * CharacterLiteral,
     * ClassInstanceCreation,
     * ConditionalExpression,
     * FieldAccess,
     * InfixExpression,
     * InstanceofExpression,
     * MethodInvocation,
     * Name,
     * NullLiteral,
     * NumberLiteral,
     * ParenthesizedExpression,
     * PostfixExpression,
     * PrefixExpression,
     * StringLiteral,
     * SuperFieldAccess,
     * SuperMethodInvocation,
     * ThisExpression,
     * TypeLiteral,
     * VariableDeclarationExpression
     * </pre>
     *
     * @param expression the {@link Expression expression} being recorded (cannot be <code>null</code>)
     * @param nodeName the name of the expression node that is created (cannot be <code>null</code> or empty)
     * @param parentNode the parent {@link Node node} where the expression is being recorded (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void recordExpression( final Expression expression,
                                     final String nodeName,
                                     final Node parentNode ) throws Exception {
        // TODO handle all the different types of expressions
        final Node expressionNode = parentNode.addNode(nodeName, ClassFileSequencerLexicon.EXPRESSION);
        expressionNode.setProperty(ClassFileSequencerLexicon.CONTENT, expression.toString());
        recordSourceReference(expression, expressionNode);
    }

    /**
     * <pre>
     * ImportDeclaration:
     *      import [ static ] Name [ . * ] ;
     * </pre>
     *
     * @param compilationUnit the {@link CompilationUnit compilation unit} being recorded (cannot be <code>null</code>)
     * @param outputNode the parent {@link Node node} (cannot be <code>null</code>)
     * @throws Exception if there is a problem
     */
    protected void recordImports( final CompilationUnit compilationUnit,
                                  final Node outputNode ) throws Exception {
        @SuppressWarnings( "unchecked" )
        final List<ImportDeclaration> imports = compilationUnit.imports();

        if ((imports != null) && !imports.isEmpty()) {
            final Node containerNode = outputNode.addNode(ClassFileSequencerLexicon.IMPORTS, ClassFileSequencerLexicon.IMPORTS);

            for (final ImportDeclaration mport : imports) {
                final Node importNode = containerNode.addNode(mport.getName().getFullyQualifiedName(),
                                                              ClassFileSequencerLexicon.IMPORT);
                importNode.setProperty(ClassFileSequencerLexicon.STATIC, mport.isStatic());
                importNode.setProperty(ClassFileSequencerLexicon.ON_DEMAND, mport.isOnDemand());

                recordSourceReference(mport, importNode);
            }
        }
    }

    /**
     * <pre>
     * PackageDeclaration:
     *     [ Javadoc ] { Annotation } package Name ;
     * </pre>
     *
     * @param compilationUnit the {@link CompilationUnit compilation unit} whose package is being recorded (cannot be
     *        <code>null</code>)
     * @param outputNode the output node (cannot be <code>null</code>)
     * @return the package {@link Node node} or the passed in <code>outputNode</code> if a package is not found
     * @throws Exception if there is a problem
     */
    protected Node recordPackage( final CompilationUnit compilationUnit,
                                  final Node outputNode ) throws Exception {
        final PackageDeclaration pkg = compilationUnit.getPackage();

        if (pkg == null) {
            return outputNode;
        }

        Node pkgNode = outputNode;

        { // create node for each segment of the package name
            final String pkgName = pkg.getName().getFullyQualifiedName();
            final String[] packagePath = pkgName.split("\\.");

            if (pkgName.length() > 0) {
                for (final String segment : packagePath) {
                    pkgNode = pkgNode.addNode(segment);
                    pkgNode.addMixin(ClassFileSequencerLexicon.PACKAGE);
                }
            }
        }

        { // Javadocs
            final Javadoc javadoc = pkg.getJavadoc();

            if (javadoc != null) {
                record(javadoc, pkgNode);
            }
        }

        { // annotations
            @SuppressWarnings( "unchecked" )
            final List<Annotation> annotations = pkg.annotations();

            if ((annotations != null) && !annotations.isEmpty()) {
                for (final Annotation annotation : annotations) {
                    record(annotation, pkgNode);
                }
            }
        }

        recordSourceReference(pkg, pkgNode);
        return pkgNode;
    }

    protected void recordSourceReference( final ASTNode astNode,
                                          final Node jcrNode ) throws Exception {
        jcrNode.setProperty(ClassFileSequencerLexicon.START_POSITION, astNode.getStartPosition());
        jcrNode.setProperty(ClassFileSequencerLexicon.LENGTH, astNode.getLength());
    }

    protected void recordTypes( final CompilationUnit unit,
                                final Node compilationUnitNode,
                                final Node pkgNode ) throws Exception {
        @SuppressWarnings( "unchecked" )
        final List<AbstractTypeDeclaration> topLevelTypes = unit.types();

        if ((topLevelTypes != null) && !topLevelTypes.isEmpty()) {
            final List<Node> types = new ArrayList<>(topLevelTypes.size());

            for (final AbstractTypeDeclaration type : topLevelTypes) {
                if (type instanceof TypeDeclaration) {
                    types.add(record((TypeDeclaration)type, pkgNode));
                } else if (type instanceof EnumDeclaration) {
                    types.add(record((EnumDeclaration)type, pkgNode));
                } else if (type instanceof AnnotationTypeDeclaration) {
                    types.add(record((AnnotationTypeDeclaration)type, pkgNode));
                } else {
                    assert false;
                    LOGGER.error(JavaFileI18n.unhandledTopLevelType, type.getName().getFullyQualifiedName());
                }
            }

            final ValueFactory factory = this.context.valueFactory();
            final Value[] refs = new Value[topLevelTypes.size()];
            int i = 0;

            for (final Node typeNode : types) {
                refs[i++] = factory.createValue(typeNode);
            }

            compilationUnitNode.setProperty(ClassFileSequencerLexicon.TYPES, refs);
        }

        recordSourceReference(compilationUnit, compilationUnitNode);
    }

}