/// <summary>
		/// Adds the elements of an array to the end of this FieldDeclarationCollection.
		/// </summary>
		/// <param name="items">
		/// The array whose elements are to be added to the end of this FieldDeclarationCollection.
		/// </param>
		public virtual void AddRange(FieldDeclaration[] items)
		{
			foreach (FieldDeclaration item in items)
			{
				this.List.Add(item);
			}
		}

        public override void ExtendDeclaration(IDeclarationModel declaration, CompilationModel model)
        {
            // this only applies to properties
            var propDecl = declaration as PropertyDeclaration;
            if (propDecl == null || propDecl.Container == null)
                return;

            var container = propDecl.Container;
            container.RemoveMember(propDecl);

            var field = new FieldDeclaration
            {
                Container = container,
                OriginatingNode = propDecl.OriginatingNode,
                OriginatingTree = propDecl.OriginatingTree,
                Definition = new FieldDefinition
                {
                    Name = propDecl.Name,
                    ContainingType = propDecl.Definition.ContainingType,
                    Kind = DefinitionKind.Member,
                    MemberKind = MemberDefinitionKind.Field,
                    Type = propDecl.Definition.Type
                }
            };

            field.Definition.Modifiers.Apply(propDecl.Definition.Modifiers);
            container.AddMember(field);
        }

        // Fields there is only on Classes or Structs
        public override void VisitFieldDeclaration(FieldDeclaration fd)
        {
            ClassesAndStructs cs = (ClassesAndStructs)GetDeclarationFor(fd);

            string name = fd.Variables.Single().Name;
            string returnType = fd.ReturnType.ToString();
            Visibility v = new Visibility(VisibilityMapper.Map(fd.Modifiers));

            if (al.CheckFlag(fd.Modifiers, Modifiers.Const))
            {
                Constant cf = new Constant(v, name, returnType, fd.Variables.Single().Initializer.ToString());
                cs.ConstantFields.Add(cf);
            }

            else
            {
                Field f = new Field(v, name,
                     al.CheckFlag(fd.Modifiers, Modifiers.Static),
                     al.CheckFlag(fd.Modifiers, Modifiers.Readonly),
                     returnType
                );

                cs.Fields.Add(f);
            }
            AddToNotDefaultReferencedTypes(cs, returnType);

            // call base to forward execution
            base.VisitFieldDeclaration(fd);
        }

		public void Run (RefactoringContext context)
		{
			var property = context.GetNode<PropertyDeclaration> ();
			
			string backingStoreName = context.GetNameProposal (property.Name);
			
			// create field
			var backingStore = new FieldDeclaration ();
			backingStore.ReturnType = property.ReturnType.Clone ();
			
			var initializer = new VariableInitializer (backingStoreName);
			backingStore.Variables.Add (initializer);
			
			// create new property & implement the get/set bodies
			var newProperty = (PropertyDeclaration)property.Clone ();
			var id1 = new IdentifierExpression (backingStoreName);
			var id2 = new IdentifierExpression (backingStoreName);
			newProperty.Getter.Body = new BlockStatement () {
				new ReturnStatement (id1)
			};
			newProperty.Setter.Body = new BlockStatement () {
				new ExpressionStatement (new AssignmentExpression (id2, AssignmentOperatorType.Assign, new IdentifierExpression ("value")))
			};
			
			using (var script = context.StartScript ()) {
				script.Replace (property, newProperty);
				script.InsertBefore (property, backingStore);
				script.Link (initializer, id1, id2);
			}
		}

		void GenerateNewScript(Script script, FieldDeclaration fieldDeclaration, RefactoringContext context)
        {
            var firstOrNullObject = fieldDeclaration.Variables.FirstOrNullObject();
		    if(firstOrNullObject==null)
                return;
			var matchedNodes = ComputeMatchNodes(context, firstOrNullObject);

		    foreach (var matchNode in matchedNodes)
            {
                var parent = matchNode.Parent;
                if (matchNode is VariableInitializer)
                {
                    script.Remove(parent);
                }
                else
                if (matchNode is IdentifierExpression)
                {
                    if(parent is AssignmentExpression)
                    {
                        script.Remove(parent.Parent);
                    }
                    else
                    {
                        var clone = (IdentifierExpression)matchNode.Clone();
                        clone.Identifier = "TODO";
                        script.Replace(matchNode, clone);
                    }
                }
            }
        }

        public override void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
        {
            CLRType t = m_clrTypes.Value.Last.Value;
            string name = fieldDeclaration.Variables.Single().Name;
            string returnType =  fieldDeclaration.ReturnType.ToString();
            Visibility v = new Visibility(VisibilityMapper.Map(fieldDeclaration.Modifiers));

            if (CheckFlag(fieldDeclaration.Modifiers, Modifiers.Const))
            {
                ConstField cf = new ConstField(v, name, returnType, fieldDeclaration.Variables.Single().Initializer.ToString());
                t.ConstantFields.Add(cf);   // connect
            }

            else
            {
                Field f = new Field(
                     CheckFlag(fieldDeclaration.Modifiers, Modifiers.Static),
                     CheckFlag(fieldDeclaration.Modifiers, Modifiers.Readonly),
                     v,
                     CheckFlag(fieldDeclaration.Modifiers, Modifiers.Virtual),
                     name,
                     CheckFlag(fieldDeclaration.Modifiers, Modifiers.Abstract),
                     returnType
                );

                t.Fields.Add(f);    // connect
            }
            AddToNotDefaultReferencedTypes(returnType);

            // call base to forward execution
            base.VisitFieldDeclaration(fieldDeclaration);
        }

 internal FieldDeclaration AddFieldForLocal(SimpleName localName, Expression initialValue, ISourceLocation sourceLocation) {
   FieldDeclaration field = new FieldDeclaration(null, FieldDeclaration.Flags.Static, TypeMemberVisibility.Private, 
     TypeExpression.For(initialValue.Type), new NameDeclaration(localName.Name, localName.SourceLocation), null, sourceLocation);
   field.SetContainingTypeDeclaration(this, false);
   this.members.Add(field);
   this.localFieldFor.Add(localName.Name.UniqueKeyIgnoringCase, field.FieldDefinition);
   return field;
 }

 public override void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
 {
     if (fieldDeclaration.HasModifier(Modifiers.Static))
     {
         this.CheckDependency(fieldDeclaration.ReturnType);
         base.VisitFieldDeclaration(fieldDeclaration);
     }
 }

 public void Verify()
 {
     FieldDeclaration field = new FieldDeclaration("_customer", new CodeDomTypeReference(typeof(int)));
     Assert.AreEqual("_customer", field.Name);
     field.Initialize = true;
     CodeMemberField codefield = field.ToCodeDom();
     Assert.AreEqual("_customer", codefield.Name);
     Assert.AreEqual("System.Int32", codefield.Type.BaseType);
 }

 internal void AddStandardMembers(Compilation compilation, List<Statement> bodyOfMainRoutine) {
   NameDeclaration labelOfFirstStatement = new NameDeclaration(compilation.NameTable.GetNameFor("<<first statement>>"), SourceDummy.SourceLocation);
   FieldDeclaration labelField = new FieldDeclaration(null, 0, TypeMemberVisibility.Private,
     TypeExpression.For(compilation.PlatformType.SystemInt32.ResolvedType), labelOfFirstStatement, null, SourceDummy.SourceLocation);
   this.members.Add(labelField);
   this.AddMainMethod(compilation, bodyOfMainRoutine, labelField);
   this.AddEntryPointMethod(compilation);
   this.AddConstructor(compilation);
 }

            public override object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
            {
                if ((fieldDeclaration.Modifiers & Modifiers.Const) == Modifiers.Const)
                {
                    UnlockWith(fieldDeclaration);
                }

                return base.VisitFieldDeclaration(fieldDeclaration, data);
            }

        public FieldReferenceExpression(Expression target,FieldDeclaration field)
        {
            if (target==null)
                throw new ArgumentNullException("target");
            if (field==null)
                throw new ArgumentNullException("field");

            this.target = target;
            this.declaringField = field;
        }

 private void AddMainMethod(Compilation compilation, List<Statement> bodyOfMainRoutine, FieldDeclaration labelField) {
   MethodDeclaration mainMethod = new MethodDeclaration(null, 0, TypeMemberVisibility.Public,
     TypeExpression.For(compilation.PlatformType.SystemVoid.ResolvedType), null, new NameDeclaration(compilation.NameTable.GetNameFor("Main"), SourceDummy.SourceLocation), null, 
     null, null, new BlockStatement(bodyOfMainRoutine, this.SourceLocation), this.SourceLocation);
   bodyOfMainRoutine.Add(new SwitchStatement(new SimpleName(labelField.Name, SourceDummy.SourceLocation, false), this.cases, SourceDummy.SourceLocation));
   bodyOfMainRoutine.Add(new LabeledStatement(new NameDeclaration(labelField.Name, SourceDummy.SourceLocation), new EmptyStatement(false, SourceDummy.SourceLocation), SourceDummy.SourceLocation));
   this.AddLabel(new SimpleName(labelField.Name, SourceDummy.SourceLocation, false));
   this.members.Add(mainMethod);
   this.mainMethod = mainMethod;
 }

        public static OverloadsCollection Create(IEmitter emitter, FieldDeclaration fieldDeclaration)
        {
            string key = fieldDeclaration.GetHashCode().ToString();
            if (emitter.OverloadsCache.ContainsKey(key))
            {
                return emitter.OverloadsCache[key];
            }

            return new OverloadsCollection(emitter, fieldDeclaration);
        }

        protected FieldDeclaration GetFieldDeclaration(String name, AstType propertyType)
        {
            var declaration = new FieldDeclaration();
            declaration.Name = name;
            declaration.Modifiers = Modifiers.Public;
            declaration.ReturnType = propertyType;

            IDELogger.Log("BaseRefactoringDialog::GetFieldDeclaration -- {0}", declaration.Name);

            return declaration;
        }

		public static List<CSField> Parse(FieldDeclaration fieldNode)
		{
			var returnList = new List<CSField>();
			EnumProtectionLevel protectionLevel = EnumProtectionLevel.None;
			if ((fieldNode.Modifiers & Modifiers.Public) == Modifiers.Public)
			{
				protectionLevel = EnumProtectionLevel.Public;
			}
			else if ((fieldNode.Modifiers & Modifiers.Private) == Modifiers.Private)
			{
				protectionLevel = EnumProtectionLevel.Private;
			}
			else if ((fieldNode.Modifiers & Modifiers.Protected) == Modifiers.Protected)
			{
				protectionLevel = EnumProtectionLevel.Protected;
			}
			else if ((fieldNode.Modifiers & Modifiers.Internal) == Modifiers.Internal)
			{
				protectionLevel = EnumProtectionLevel.Internal;
			}
			string typeName;
			string typeNamespace;
			DotNetParserHelper.SplitType(fieldNode.ReturnType.ToString(), out typeName, out typeNamespace);
			foreach(VariableInitializer variableNode in fieldNode.Variables)
			{
				CSField fieldObject = new CSField
				{
					TypeNamespace = typeNamespace,
					TypeName = typeName,
					FieldName = variableNode.Name,
					ProtectionLevel = protectionLevel
				};
				if(variableNode.Initializer != null)
				{
					if(variableNode.Initializer is PrimitiveExpression)
					{
						PrimitiveExpression primitiveExpression = (PrimitiveExpression)variableNode.Initializer;
						fieldObject.FieldValue = primitiveExpression.Value;
					}
				}
				foreach (var attributeSectionNode in fieldNode.Attributes)
				{
					foreach (var attributeNode in attributeSectionNode.Attributes)
					{
						var attribute = CSAttribute.Parse(attributeNode);
						fieldObject.AttributeList.Add(attribute);
					}
				}
				returnList.Add(fieldObject);
			}
			return returnList;
		}

		public override IEnumerable<CodeAction> GetActions(RefactoringContext context)
		{
			var property = context.GetNode<PropertyDeclaration> ();
			if (property == null || !property.NameToken.Contains(context.Location))
				yield break;

			if (!IsNotImplemented (context, property.Getter.Body) ||
			    !IsNotImplemented (context, property.Setter.Body)) {
				yield break;
			}
			
			yield return new CodeAction(context.TranslateString("Implement property"), script => {
				string backingStoreName = context.GetNameProposal (property.Name);
				
				// create field
				var backingStore = new FieldDeclaration ();
				if (property.Modifiers.HasFlag (Modifiers.Static))
					backingStore.Modifiers |= Modifiers.Static;

				if (property.Setter.IsNull)
					backingStore.Modifiers |= Modifiers.Readonly;
				
				backingStore.ReturnType = property.ReturnType.Clone ();
				
				var initializer = new VariableInitializer (backingStoreName);
				backingStore.Variables.Add (initializer);
				
				// create new property & implement the get/set bodies
				var newProperty = (PropertyDeclaration)property.Clone ();
				Expression id1;
				if (backingStoreName == "value")
					id1 = new ThisReferenceExpression().Member("value");
				else
					id1 = new IdentifierExpression (backingStoreName);
				Expression id2 = id1.Clone();
				newProperty.Getter.Body = new BlockStatement () {
					new ReturnStatement (id1)
				};
				if (!property.Setter.IsNull) {
					newProperty.Setter.Body = new BlockStatement () {
						new AssignmentExpression (id2, AssignmentOperatorType.Assign, new IdentifierExpression ("value"))
					};
				}
				
				script.Replace (property, newProperty);
				script.InsertBefore (property, backingStore);
				if (!property.Setter.IsNull)
					script.Link (initializer, id1, id2);
				else
					script.Link (initializer, id1);
			}, property.NameToken);
		}

 private OverloadsCollection(IEmitter emitter, FieldDeclaration fieldDeclaration)
 {
     this.Emitter = emitter;
     this.Name = emitter.GetFieldName(fieldDeclaration);
     this.JsName = this.Emitter.GetEntityName(fieldDeclaration, false, true);
     this.Inherit = !fieldDeclaration.HasModifier(Modifiers.Static);
     this.Static = fieldDeclaration.HasModifier(Modifiers.Static);
     this.Member = this.FindMember(fieldDeclaration);
     this.TypeDefinition = this.Member.DeclaringTypeDefinition;
     this.Type = this.Member.DeclaringType;
     this.InitMembers();
     this.Emitter.OverloadsCache[fieldDeclaration.GetHashCode().ToString()] = this;
 }

		public IEnumerable<CodeAction> GetActions(RefactoringContext context)
		{
			var pexpr = context.GetNode<PrimitiveExpression>();
			if (pexpr == null)
				yield break;
			var statement = context.GetNode<Statement>();
			if (statement == null) {
				yield break;
			}

			var resolveResult = context.Resolve(pexpr);

			yield return new CodeAction(context.TranslateString("Create local constant"), script => {
				string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
				var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
				if (service != null)
					name = service.CheckName(context, name, AffectedEntity.LocalConstant);

				var initializer = new VariableInitializer(name, pexpr.Clone());
				var decl = new VariableDeclarationStatement() {
					Type = context.CreateShortType(resolveResult.Type),
					Modifiers = Modifiers.Const,
					Variables = { initializer }
				};

				script.InsertBefore(statement, decl);
				var variableUsage = new IdentifierExpression(name);
				script.Replace(pexpr, variableUsage);
				script.Link(initializer.NameToken, variableUsage);
			});

			yield return new CodeAction(context.TranslateString("Create constant field"), script => {
				string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
				var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
				if (service != null)
					name = service.CheckName(context, name, AffectedEntity.ConstantField);

				var initializer = new VariableInitializer(name, pexpr.Clone());

				var decl = new FieldDeclaration() {
					ReturnType = context.CreateShortType(resolveResult.Type),
					Modifiers = Modifiers.Const,
					Variables = { initializer }
				};

				var variableUsage = new IdentifierExpression(name);
				script.Replace(pexpr, variableUsage);
//				script.Link(initializer.NameToken, variableUsage);
				script.InsertWithCursor(context.TranslateString("Create constant"), Script.InsertPosition.Before, decl);
			});
		}

		static PropertyDeclaration GeneratePropertyDeclaration (RefactoringContext context, FieldDeclaration field, VariableInitializer initializer)
		{
			var mod = ICSharpCode.NRefactory.CSharp.Modifiers.Public;
			if (field.HasModifier (ICSharpCode.NRefactory.CSharp.Modifiers.Static))
				mod |= ICSharpCode.NRefactory.CSharp.Modifiers.Static;
			
			return new PropertyDeclaration () {
				Modifiers = mod,
				Name = context.GetNameProposal (initializer.Name, false),
				ReturnType = field.ReturnType.Clone (),
				Getter = new Accessor () {
					Body = new BlockStatement () {
						new ReturnStatement (new IdentifierExpression (initializer.Name))
					}
				}
			};
		}