public ClassModifier(AccessModifier accessModifier)
 {
     this.AccessModifier = accessModifier;
     this.Static = false;
     this.Abstract = false;
     this.Partial = false;
 }

 public static string GetModifier(AccessModifier? access, MemberModifier? modifier)
 {
     if (modifier == null)
         return access.ToString().ToLower();
     else
         return string.Format("{0} {1}", access.ToString().ToLower(), modifier.ToString().ToLower());
 }

 /// <summary>
 /// Get field value.
 /// </summary>
 /// <param name="access">Specify field access modifier.</param>
 /// <param name="obj">Object where field is defined.</param>
 /// <param name="fieldName">Field name.</param>
 /// <param name="lookInBase">Specify if need to look in Base classes.</param>
 /// <returns>Field value</returns>
 public static object GetField(AccessModifier access, object obj, string fieldName, bool lookInBase)
 {
     CheckObject(obj);
     FieldInfo fi = GetField(access, obj.GetType(), fieldName, lookInBase);
     IsMember(obj, fi, fieldName, MemberType.Field);
     return fi.GetValue(obj);
 }

 public Field(string name, string type, bool isStatic, AccessModifier am)
 {
     Name = name;
     Type = type;
     Static = isStatic;
     AccessModifier = am;
 }

 public FunctionDeclarationHeader(SymbolDefinition name, AccessModifier visibility, FunctionType type)
     : base(CodeElementType.FunctionDeclarationHeader)
 {
     this.FunctionName = name;
     this.Visibility = visibility;
     this.UserDefinedType = type != null ? type : FunctionType.Undefined;
     this.Profile = new ParametersProfile();
 }

 public Constructor(AccessModifier accessModifier, String name)
 {
     this.Modifier = new ConstructorModifier(accessModifier);
     this.Name = name;
     this.Parameters = new List<MethodParameter>();
     this.GenericParameters = new List<String>();
     this.Body = new CodeBlockCollection();
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="AccessModifier">Access modifier</param>
 /// <param name="ClassName">Class name</param>
 /// <param name="ParameterList">Parameter list</param>
 /// <param name="Body">Body of the constructor</param>
 /// <param name="Parser">Parser to use</param>
 public Constructor(AccessModifier AccessModifier, string ClassName, IParameter[] ParameterList, string Body, IParser Parser)
     : base(Parser)
 {
     this.AccessModifier = AccessModifier;
     this.ClassName = ClassName;
     this.Parameters = ParameterList.ToList();
     this.Body = Body;
 }

 public Method(string name, string retType, bool isStatic, AccessModifier am, params string[] paramTypes)
 {
     Name = name;
     ReturnType = retType;
     Static = isStatic;
     AccessModifier = am;
     ParameterTypes = paramTypes;
 }

        /// <summary>
        /// Visits the syntax node.
        /// </summary>
        /// <param name="parentNode">Node</param>
        /// <param name="isStart">Is start state</param>
        /// <param name="accMod">Access modifier</param>
        internal void Visit(MachineDeclaration parentNode, bool isStart, AccessModifier accMod)
        {
            var node = new StateDeclaration(base.TokenStream.Program, parentNode,
                isStart, parentNode.IsModel);
            node.AccessModifier = accMod;
            node.StateKeyword = base.TokenStream.Peek();

            base.TokenStream.Index++;
            base.TokenStream.SkipWhiteSpaceAndCommentTokens();

            if (base.TokenStream.Done ||
                base.TokenStream.Peek().Type != TokenType.Identifier)
            {
                throw new ParsingException("Expected state identifier.",
                    new List<TokenType>
                {
                    TokenType.Identifier
                });
            }

            base.TokenStream.CurrentState = base.TokenStream.Peek().Text;
            base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit,
                TokenType.StateIdentifier));

            node.Identifier = base.TokenStream.Peek();

            base.TokenStream.Index++;
            base.TokenStream.SkipWhiteSpaceAndCommentTokens();

            if (base.TokenStream.Done ||
                base.TokenStream.Peek().Type != TokenType.LeftCurlyBracket)
            {
                throw new ParsingException("Expected \"{\".",
                    new List<TokenType>
                {
                    TokenType.LeftCurlyBracket
                });
            }

            base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit,
                TokenType.StateLeftCurlyBracket));

            node.LeftCurlyBracketToken = base.TokenStream.Peek();

            base.TokenStream.Index++;
            base.TokenStream.SkipWhiteSpaceAndCommentTokens();

            if (base.TokenStream.Program is PSharpProgram)
            {
                this.VisitNextPSharpIntraStateDeclaration(node);
            }
            else
            {
                this.VisitNextPIntraStateDeclaration(node);
            }

            parentNode.StateDeclarations.Add(node);
        }

        /// <summary>
        /// Visits the syntax node.
        /// </summary>
        /// <param name="parentNode">Node</param>
        /// <param name="typeIdentifier">Type identifier</param>
        /// <param name="identifier">Identifier</param>
        /// <param name="accMod">Access modifier</param>
        /// <param name="inhMod">Inheritance modifier</param>
        /// <param name="isAsync">Is async</param>
        /// <param name="isPartial">Is partial</param>
        internal void Visit(MachineDeclaration parentNode, Token typeIdentifier, Token identifier,
            AccessModifier accMod, InheritanceModifier inhMod, bool isAsync, bool isPartial)
        {
            var node = new MethodDeclaration(base.TokenStream.Program, parentNode);
            node.AccessModifier = accMod;
            node.InheritanceModifier = inhMod;
            node.TypeIdentifier = typeIdentifier;
            node.Identifier = identifier;
            node.IsAsync = isAsync;
            node.IsPartial = isPartial;

            node.LeftParenthesisToken = base.TokenStream.Peek();

            base.TokenStream.Index++;
            base.TokenStream.SkipWhiteSpaceAndCommentTokens();

            while (!base.TokenStream.Done &&
                base.TokenStream.Peek().Type != TokenType.RightParenthesis)
            {
                base.TokenStream.Swap(new Token(base.TokenStream.Peek().TextUnit));

                node.Parameters.Add(base.TokenStream.Peek());

                base.TokenStream.Index++;
                base.TokenStream.SkipWhiteSpaceAndCommentTokens();
            }

            node.RightParenthesisToken = base.TokenStream.Peek();

            base.TokenStream.Index++;
            base.TokenStream.SkipWhiteSpaceAndCommentTokens();

            if (base.TokenStream.Done ||
                (base.TokenStream.Peek().Type != TokenType.LeftCurlyBracket &&
                base.TokenStream.Peek().Type != TokenType.Semicolon))
            {
                throw new ParsingException("Expected \"{\" or \";\".",
                    new List<TokenType>
                {
                    TokenType.LeftCurlyBracket,
                    TokenType.Semicolon
                });
            }

            if (base.TokenStream.Peek().Type == TokenType.LeftCurlyBracket)
            {
                var blockNode = new BlockSyntax(base.TokenStream.Program, parentNode, null);
                new BlockSyntaxVisitor(base.TokenStream).Visit(blockNode);
                node.StatementBlock = blockNode;
            }
            else if (base.TokenStream.Peek().Type == TokenType.Semicolon)
            {
                node.SemicolonToken = base.TokenStream.Peek();
            }

            parentNode.MethodDeclarations.Add(node);
        }

 public override System.ComponentModel.TypeConverter.StandardValuesCollection GetStandardValues(System.ComponentModel.ITypeDescriptorContext context)
 {
     AccessModifier[] accessModifierArr = new AccessModifier[5];
     accessModifierArr[1] = AccessModifier.Assembly;
     accessModifierArr[2] = AccessModifier.Private;
     accessModifierArr[3] = AccessModifier.Family;
     accessModifierArr[4] = AccessModifier.FamilyOrAssembly;
     return new System.ComponentModel.TypeConverter.StandardValuesCollection(accessModifierArr);
 }

 /// <summary>Creates functions or procedure</summary>
 public Function(QualifiedName name, IList<ParameterDescription> inputs, IList<ParameterDescription> outputs, IList<ParameterDescription> inouts, ParameterDescription returning, AccessModifier visibility = AccessModifier.Private)
 {
     QualifiedName = name;
     Profile = new ParametersProfile();
     Profile.InputParameters  = inputs  ?? new List<ParameterDescription>();
     Profile.OutputParameters = outputs ?? new List<ParameterDescription>();
     Profile.InoutParameters  = inouts  ?? new List<ParameterDescription>();
     Profile.ReturningParameter = returning;
     Visibility = visibility;
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="AccessModifier">Access modifier</param>
 /// <param name="Modifier">Modifier</param>
 /// <param name="Type">Type</param>
 /// <param name="FunctionName">Function name</param>
 /// <param name="ParameterList">Parameter list</param>
 /// <param name="Body">Body of the function</param>
 /// <param name="Parser">Parser to use</param>
 public Function(AccessModifier AccessModifier, Modifiers Modifier, string Type,
     string FunctionName, IParameter[] ParameterList, string Body, IParser Parser)
     : base(Parser)
 {
     this.AccessModifier = AccessModifier;
     this.Modifier = Modifier;
     this.Type = Type;
     this.Name = FunctionName;
     this.Parameters = ParameterList.ToList();
     this.Body = Body;
 }

 public Class(AccessModifier AccessModifier, Modifiers Modifier, string ClassName,
     string Namespace)
     : base()
 {
     Properties = new List<IProperty>();
     Usings = new List<Using>();
     Constructors = new List<IFunction>();
     Functions = new List<IFunction>();
     this.ClassName = ClassName;
     this.AccessModifier = AccessModifier;
     this.Modifier = Modifier;
     this.Namespace = Namespace;
 }

		public static string WriteDeclarator(AccessModifier am, string type, string name) {
			string s;
			switch (am) {
				case AccessModifier._Public:            s = "public "; break;
				case AccessModifier._Protected:         s = "protected "; break;
				case AccessModifier._Private:           s = "private "; break;
				case AccessModifier._Internal:          s = "internal "; break;
				case AccessModifier._ProtectedInternal: s = "protected internal "; break;
				case AccessModifier._None:              s = ""; break;
				default: throw Utils.ArgumentException("am");
			}
			return s + type + " " + name;
		}

 public Class(AccessModifier modifier, String name)
 {
     this.Modifier = new ClassModifier(modifier);
     this.Name = name;
     this.ImplementInterfaces = new List<TypeName>();
     this.Fields = new List<Field>();
     this.Properties = new List<Property>();
     this.Constructors = new List<Constructor>();
     this.Methods = new List<Method>();
     this.Interfaces = new List<Interface>();
     this.Classes = new List<Class>();
     this.Enums = new List<Enum>();
 }

        public override void Write(AccessModifier modifier)
        {
            var writer = this.TextWriter;

            switch (modifier)
            {
                case AccessModifier.Public: writer.Write("Public"); break;
                case AccessModifier.Private: writer.Write("Private"); break;
                case AccessModifier.Protected: writer.Write("Protected"); break;
                case AccessModifier.Internal: writer.Write("Internal"); break;
                case AccessModifier.ProtectedInternal: writer.Write("Protected Internal"); break;
                default: throw new NotSupportedException();
            }
        }

        public virtual void AddProperty(AccessModifier accessModifier, VirtualModifier virtualModifier,
            [NotNull] string propertyTypeName, [NotNull] string propertyName, [NotNull] IndentedStringBuilder sb)
        {
            Check.NotEmpty(propertyTypeName, nameof(propertyTypeName));
            Check.NotEmpty(propertyName, nameof(propertyName));
            Check.NotNull(sb, nameof(sb));

            AppendAccessModifier(accessModifier, sb);
            AppendVirtualModifier(virtualModifier, sb);
            sb.Append(propertyTypeName);
            sb.Append(" ");
            sb.Append(propertyName);
            sb.AppendLine(" { get; set; }");
        }

		public PropertyMember(string name, string serverType, string clientType, AccessModifier accessModifier, string backingFieldName, string backingFieldServerType, string backingFieldClientType, bool hasGetter, bool hasSetter, string valueChangedHookName, bool clientInject) {
			if (string.IsNullOrEmpty(name)) throw Utils.ArgumentException("name");
			if (string.IsNullOrEmpty(backingFieldName)) throw Utils.ArgumentException("backingFieldName");
			if (!hasGetter && !hasSetter) throw Utils.ArgumentException("Must have getter or setter.");
			if (string.IsNullOrEmpty(serverType) != string.IsNullOrEmpty(backingFieldServerType)) throw Utils.ArgumentException("serverType and backingFieldServerType must both be either null or non-null.");
			if (string.IsNullOrEmpty(clientType) != string.IsNullOrEmpty(backingFieldClientType)) throw Utils.ArgumentException("clientType and backingFieldClientType must both be either null or non-null.");
			if (valueChangedHookName != null && !ParserUtils.IsValidUnqualifiedName(valueChangedHookName)) throw Utils.ArgumentException("valueChangedHookName");
			
			this.name = name;
			this.serverType = serverType;
			this.clientType = clientType;
			this.accessModifier = accessModifier;
			this.backingFieldName = backingFieldName;
			this.backingFieldServerType = backingFieldServerType;
			this.backingFieldClientType = backingFieldClientType;
			this.hasGetter = hasGetter;
			this.hasSetter = hasSetter;
			this.valueChangedHookName = valueChangedHookName;
			this.clientInject = clientInject;
		}

        public virtual void BeginClass(AccessModifier accessModifier, [NotNull] string className,
            bool isPartial, [NotNull] IndentedStringBuilder sb, [CanBeNull] ICollection<string> inheritsFrom = null)
        {
            Check.NotEmpty(className, nameof(className));
            Check.NotNull(sb, nameof(sb));

            AppendAccessModifier(accessModifier, sb);
            if (isPartial)
            {
                sb.Append("partial ");
            }
            sb.Append("class ");
            sb.Append(className);
            if (inheritsFrom != null && inheritsFrom.Count > 0)
            {
                sb.Append(" : ");
                sb.Append(string.Join(", ", inheritsFrom));
            }
            sb.AppendLine();
            sb.AppendLine("{");
            sb.IncrementIndent();
        }