var rules = new[]
        {
            new FileHeaderValidatorCodeFileReader
                .ValidationRule("validation rule", "rule failed.", content => content.Contains("foo"))
        };

using VBEX.Lexer;

namespace VBEX.Parser
{
    public interface ICodeParser
    {
        ICodeFileTree Parse(string[] code);
    }
}

public interface ICodeFileTree
{
    string FileName { get; }
    CodeModuleType ModuleType { get; }
    IIdentifier Identifier { get; }
    IEnumerable<IMember> Members { get; }
}

    public class Property : IMember
    {
        public AccessModifier Accessibility { get; }
        public IIdentifier Identifier { get; }

        public ICodeBlock PropertyGet { get; }
        public ICodeBlock PropertyLet { get; }
        public ICodeBlock PropertySet { get; }
    }

public interface IMember
{
    AccessModifier Accessibility { get; }
    IIdentifier Identifier { get; }
}

    /// <summary>
    /// An abstraction representing a member in a code module.
    /// </summary>
    public interface IMember
    {
        /// <summary>
        /// The member's accessibility / scope.
        /// </summary>
        AccessModifier Accessibility { get; }

        /// <summary>
        /// The member's associated identifier.
        /// </summary>
        IIdentifier Identifier { get; }
    }

public enum AccessModifier
{
    Public,
    Private,
    Friend,
    Global
}

    /// <summary>
    /// An abstraction representing anything with a name and a type.
    /// </summary>
    public interface IIdentifier
    {
        /// <summary>
        /// A string that determines how an identifier is being referred to in code.
        /// </summary>
        string Name { get; }

        /// <summary>
        /// The type associated with the identifier.
        /// </summary>
        /// <remarks>
        /// For a field or a variable identifier, this is the variable's type.

    /// <summary>
    /// An abstraction representing a type.
    /// </summary>
    public interface IVBType
    {
        /// <summary>
        /// The exact string representation of the type's name.
        /// </summary>
        string TypeName { get; }

        /// <summary>
        /// True if an identifier of that type must be Set.
        /// </summary>
        bool? IsReference { get; }
    }

    public class ClassReferenceType : IVBType
    {
        private readonly string _typeName;

        public ClassReferenceType(string name)
        {
            _typeName = name;
        }

        public string TypeName { get { return _typeName; } }
        public bool? IsReference { get { return true; } }
    }

    public class Variant : IVBType
    {
        public string TypeName { get { return "Variant"; } }
        public bool? IsReference { get { return null; } }
    }

    /// <summary>
    /// An abstraction representing a callable member.
    /// </summary>
    public interface ICallable : IMember
    {
        /// <summary>
        /// The member's signature.
        /// </summary>
        ISignature Signature { get; }

        /// <summary>
        /// A tree structure representing the member's body.
        /// </summary>
        IExecutableTree Body { get; }
    }

    /// <summary>
    /// An abstraction representing a callable member's signature.
    /// </summary>
    public interface ISignature
    {
        /// <summary>
        /// The identifier associated with a member's signature.
        /// </summary>
        /// <remarks>
        /// For an <see cref="IMember"/> implementing <see cref="ICallable"/>,
        /// this reference should be the same as the member's <c>Identifier</c>.
        /// </remarks>
        IIdentifier Identifier { get; }

        /// <summary>

    /// <summary>
    /// An abstraction representing an executable sequence of instructions.
    /// </summary>
    public interface IExecutableTree
    {

    }