private bool FieldIsNotSource(IFieldDefinition fieldDefinition, IExpression source)
 {
     var bound = source as BoundExpression;
     var field = bound == null? null : bound.Definition as IFieldReference;
     bool ret = bound == null || field == null || field.ResolvedField != fieldDefinition;
     return ret;
 }

        public override void TraverseChildren(IFieldDefinition field)
        {
            if (!MemberHelper.IsVisibleOutsideAssembly(field))
                return;

            _assembly.EnrollApi(field);
        }

        public override void Configure(IFieldDefinition definition)
        {
            base.Configure(definition);
            var tdefinition = definition as ITaxonFieldDefinition;
            var tManager = TaxonomyManager.GetManager();
            var tid = tdefinition.TaxonomyId;
            var taxonomy = tManager.GetTaxonomies<FlatTaxonomy>().Where(t => t.Id == tid).SingleOrDefault();
            if (taxonomy != null)
            {
                var colorsTaxa = taxonomy.Taxa.OrderBy(c => c.Title.ToString());
                this.RenderChoicesAs = Telerik.Sitefinity.Web.UI.Fields.Enums.RenderChoicesAs.DropDown;

                // or you can use Telerik.Sitefinity.Web.UI.Fields.Enums.RenderChoicesAs.CheckBoxes for multiple choice

                this.Choices.Clear();
                foreach (var taxon in colorsTaxa)
                {
                    var choice = new ChoiceItem();
                    choice.Value = taxon.Id.ToString();
                    choice.Text = taxon.Title;
                    choice.Enabled = true;
                    this.Choices.Add(choice);
                }
            }
        }

 /// <summary>
 /// Returns the field from the closest base class that is hidden by the given field according to C# rules.
 /// </summary>
 public static IFieldDefinition GetHiddenField(IFieldDefinition derivedClassField) {
   var typeDef = derivedClassField.ContainingTypeDefinition;
   foreach (ITypeReference baseClassReference in typeDef.BaseClasses) {
     IFieldDefinition hiddenField = GetHiddenField(derivedClassField, baseClassReference.ResolvedType);
     if (!(hiddenField is Dummy)) return hiddenField;
   }
   return Dummy.FieldDefinition;
 }

        private void WriteFieldDefinition(IFieldDefinition field)
        {
            if (field.IsSpecialName)
                return;

            // Do we care about volatile?
            WriteAttributes(field.Attributes);
            if (!field.IsStatic && field.ContainingTypeDefinition.Layout == LayoutKind.Explicit)
            {
                WriteFakeAttribute("System.Runtime.InteropServices.FieldOffsetAttribute", field.Offset.ToString());
            }

            if (!field.ContainingTypeDefinition.IsEnum)
            {
                WriteVisibility(field.Visibility);

                if (field.Type.IsUnsafeType())
                    WriteKeyword("unsafe");

                if (field.IsCompileTimeConstant)
                    WriteKeyword("const");
                else
                {
                    if (field.IsStatic)
                        WriteKeyword("static");
                    if (field.IsReadOnly)
                        WriteKeyword("readonly");
                }

                if (!field.IsCompileTimeConstant && field.GetHiddenBaseField(_filter) != Dummy.Field)
                    WriteKeyword("new");

                WriteTypeName(field.Type);
                WriteIdentifier(field.Name);

                if (field.Constant != null && field.IsCompileTimeConstant)
                {
                    WriteSpace();
                    WriteSymbol("=", true);
                    WriteMetadataConstant(field.Constant);
                }

                WriteSymbol(";");
            }
            else
            {
                WriteIdentifier(field.Name);
                if (field.Constant != null && field.Constant.Value != null)
                {
                    WriteSpace();
                    WriteSymbol("=", true);
                    WriteMetadataConstant(field.Constant);
                }
                WriteSymbol(",");
            }
        }

        public override void Visit(IFieldDefinition fieldDefinition)
        {
            NewLine();
            Indent(2);

            AppendElementType(fieldDefinition);
            base.Visit(fieldDefinition);

            output.Append(fieldDefinition.Name.Value);
            AppendSpace();
        }

 internal override bool TryGetField(IFieldDefinition def, out uint index)
 {
     TypeFromMetadata type;
     if (this.TryGetTypeDefinition(def.ContainingTypeDefinition, out type))
     {
         FieldHandle handle;
         if (type.TryGetField(def.Name, out handle))
         {
             index = (uint)handle.GetRowNumber();
             return true;
         }
     }
     index = 0;
     return false;
 }

    /// <summary>
    /// Given a field definition in the closure class, get its reference as will be used by the methods in the closure class. 
    /// </summary>
    internal IFieldReference GetReferenceOfFieldUsedByPeers(IFieldDefinition fieldDef) {

      IFieldReference fieldReference = null;
      ITypeReference typeReference = this.ClosureDefinitionReference;
      ISpecializedNestedTypeReference nestedTypeRef = typeReference as ISpecializedNestedTypeReference;
      IGenericTypeInstanceReference genericTypeInstanceRef = typeReference as IGenericTypeInstanceReference;
      if (nestedTypeRef != null || genericTypeInstanceRef != null) {
        fieldReference = new SpecializedFieldReference() {
          ContainingType = typeReference,
          InternFactory = this.host.InternFactory,
          Name = fieldDef.Name,
          UnspecializedVersion = fieldDef,
          Type = fieldDef.Type
        };
      } else fieldReference = fieldDef;
      return fieldReference;
    }

    public override void TraverseChildren(IFieldDefinition fieldDefinition) {
      if (fieldDefinition.ContainingType.IsEnum && fieldDefinition.IsRuntimeSpecial && fieldDefinition.IsSpecialName)
        return; // implicit value field of an enum

      if (!this.printCompilerGeneratedMembers &&
        AttributeHelper.Contains(fieldDefinition.Attributes, fieldDefinition.Type.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute))
        return; // eg. a cached anonymous delegate - may have invalid symbols

      foreach (var e in fieldDefinition.ContainingTypeDefinition.Events) {
        if (e.Name == fieldDefinition.Name)
          return;   // field is probably the implicit delegate backing the event
      }

      // Figure out if this is a special fixed buffer field
      ICustomAttribute fixedBufferAttr = Utils.FindAttribute(fieldDefinition.Attributes, SpecialAttribute.FixedBuffer);

      if (fixedBufferAttr == null)
        PrintAttributes(fieldDefinition);

      if (fieldDefinition.ContainingTypeDefinition.Layout == LayoutKind.Explicit)
        PrintPseudoCustomAttribute(fieldDefinition, "System.Runtime.InteropServices.FieldOffset", fieldDefinition.Offset.ToString(), true, null);

      PrintToken(CSharpToken.Indent);

      if (fieldDefinition.IsCompileTimeConstant && fieldDefinition.ContainingType.IsEnum) {
        PrintFieldDefinitionEnumValue(fieldDefinition);
      } else {
        PrintFieldDefinitionVisibility(fieldDefinition);
        PrintFieldDefinitionModifiers(fieldDefinition);

        if (fixedBufferAttr == null) {
          PrintFieldDefinitionType(fieldDefinition);
          PrintToken(CSharpToken.Space);
          PrintFieldDefinitionName(fieldDefinition);
          if (fieldDefinition.IsCompileTimeConstant) {
            sourceEmitterOutput.Write(" = ");
            PrintFieldDefinitionValue(fieldDefinition);
          }
        } else {
          PrintFieldDefinitionFixedBuffer(fieldDefinition, fixedBufferAttr);
        }
        PrintToken(CSharpToken.Semicolon);
      }
    }

    public virtual void PrintFieldDefinitionValue(IFieldDefinition fieldDefinition) {
      Contract.Requires(fieldDefinition != null);

      // We've got context here about the field that can be used to provide a better value.
      // For enums, the IMetadataConstant is just the primitive value
      var fieldType = fieldDefinition.Type.ResolvedType;
      if (fieldType.IsEnum) {
        PrintEnumValue(fieldType, fieldDefinition.CompileTimeValue.Value);
      } else if (TypeHelper.TypesAreEquivalent(fieldDefinition.ContainingTypeDefinition, fieldType.PlatformType.SystemFloat32) && 
                 fieldType.TypeCode == PrimitiveTypeCode.Float32) {
        // Defining System.Single, can't reference the symbolic names, use constant hacks instead
        float val = (float)fieldDefinition.CompileTimeValue.Value;
        if (float.IsNegativeInfinity(val))
          sourceEmitterOutput.Write("-1.0f / 0.0f");
        else if (float.IsPositiveInfinity(val))
          sourceEmitterOutput.Write("1.0f / 0.0f");
        else if (float.IsNaN(val))
          sourceEmitterOutput.Write("0.0f / 0.0f");
        else
          sourceEmitterOutput.Write(val.ToString("R") + "f");
      } else if (TypeHelper.TypesAreEquivalent(fieldDefinition.ContainingTypeDefinition, fieldType.PlatformType.SystemFloat64) &&
                 fieldType.TypeCode == PrimitiveTypeCode.Float64) {
        // Defining System.Double, can't reference the symbolic names, use constant hacks instead
        double val = (double)fieldDefinition.CompileTimeValue.Value;
        if (double.IsNegativeInfinity(val))
          sourceEmitterOutput.Write("-1.0 / 0.0");
        else if (double.IsPositiveInfinity(val))
          sourceEmitterOutput.Write("1.0 / 0.0");
        else if (double.IsNaN(val))
          sourceEmitterOutput.Write("0.0 / 0.0");
        else
          sourceEmitterOutput.Write(val.ToString("R"));
      } else if (TypeHelper.TypesAreEquivalent(fieldDefinition.ContainingTypeDefinition, fieldType) && 
        (fieldType.TypeCode == PrimitiveTypeCode.Int32 || fieldType.TypeCode == PrimitiveTypeCode.UInt32 ||
         fieldType.TypeCode == PrimitiveTypeCode.Int64 || fieldType.TypeCode == PrimitiveTypeCode.UInt64)) {
        // Defining a core integral system type, can't reference the symbolic names, use constants
        sourceEmitterOutput.Write(fieldDefinition.CompileTimeValue.Value.ToString());
      } else {
        this.Traverse(fieldDefinition.CompileTimeValue);
      }
    }

        public override void Configure(IFieldDefinition definition)
        {
            base.Configure(definition);
            var aManager = AgentsManager.GetManager();
            var agents = aManager.GetAgents().OrderBy(a => a.Title).Where(a => a.Status == Sitefinity.GenericContent.Model.ContentLifecycleStatus.Live);
            if (agents != null)
            {
                this.RenderChoicesAs = Telerik.Sitefinity.Web.UI.Fields.Enums.RenderChoicesAs.DropDown; //
                // or you can use Telerik.Sitefinity.Web.UI.Fields.Enums.RenderChoicesAs.CheckBoxes for multiple choice

                this.Choices.Clear();
                foreach (var agent in agents)
                {
                    var choice = new ChoiceItem();
                    choice.Value = agent.Id.ToString();
                    choice.Text = agent.Title;
                    choice.Enabled = true;
                    this.Choices.Add(choice);
                }
            }
        }

 private void CheckPortableAttributes(IFieldDefinition fd, IPortable portable)
 {
     if (fd.GetFactoryId() != portable.GetFactoryId())
     {
         throw new HazelcastSerializationException(
             "Wrong Portable type! Generic portable types are not supported! " + " Expected factory-id: " +
             fd.GetFactoryId() + ", Actual factory-id: " + portable.GetFactoryId());
     }
     if (fd.GetClassId() != portable.GetClassId())
     {
         throw new HazelcastSerializationException(
             "Wrong Portable type! Generic portable types are not supported! " + "Expected class-id: " +
             fd.GetClassId() + ", Actual class-id: " + portable.GetClassId());
     }
 }

 public override void Visit(IFieldDefinition field)
 {
     if (IsMemberExternallyVisible2(field))
     {
         // Recursion
         Visit(field.Type);
     }
 }

 public void Visit(IFieldDefinition fieldDefinition)
 {
     this.traverser.Traverse(fieldDefinition);
 }

 public void Visit(IFieldDefinition fieldDefinition)
 {
     throw new NotImplementedException();
 }

 public Field(FieldInfo fieldInfo, IFieldDefinition fieldDefinition)
 {
     this.fieldInfo = fieldInfo;
     this.fieldDefinition = fieldDefinition;
 }

        public override void TraverseChildren(IFieldDefinition fieldDefinition)
{ MethodEnter(fieldDefinition);
            base.TraverseChildren(fieldDefinition);
     MethodExit();   }

 /// <summary>
 /// Traverses the field definition.
 /// </summary>
 public void Traverse(IFieldDefinition fieldDefinition)
 {
     Contract.Requires(fieldDefinition != null);
       //specialized fields are simply traversed as if they were normal fields
       if (this.preorderVisitor != null) fieldDefinition.Dispatch(this.preorderVisitor);
       if (this.stopTraversal) return;
       this.TraverseChildren(fieldDefinition);
       if (this.stopTraversal) return;
       if (this.postorderVisitor != null) fieldDefinition.Dispatch(this.postorderVisitor);
 }

    private void EmitGenericTypeObject(uint index, IFieldDefinition field, bool isStatic) {
      Contract.Requires(field != null);

      this.sourceEmitter.EmitString("(uintptr_t)((void**)((");
      if (isStatic) {
        this.EmitTypeReference(this.host.PlatformType.SystemType);
        this.sourceEmitter.EmitString(")(typeObject");
        this.EmitAdjustPointerToHeaderFromData();
        this.sourceEmitter.EmitString(")");
      } else {
        this.EmitTypeReference(this.host.PlatformType.SystemType);
        this.sourceEmitter.EmitString(")(((");
        this.EmitTypeReference(this.host.PlatformType.SystemObject);
        this.sourceEmitter.EmitString(")");
        this.sourceEmitter.EmitString("(");
        this.sourceEmitter.EmitString("_this ");
        this.EmitAdjustPointerToHeaderFromData();
        this.sourceEmitter.EmitString(")");
        this.sourceEmitter.EmitString(")->");
        this.sourceEmitter.EmitString(this.GetMangledFieldName(this.typeField));
        this.EmitAdjustPointerToHeaderFromData();
        this.sourceEmitter.EmitString(")");
      }
      this.sourceEmitter.EmitString(")->");
      this.sourceEmitter.EmitString(this.GetMangledFieldName(field));
      this.sourceEmitter.EmitString(")[" + index + "]");
    }

 /// <summary>
 /// Traverses the children of the field definition.
 /// </summary>
 public virtual void TraverseChildren(IFieldDefinition fieldDefinition)
 {
     Contract.Requires(fieldDefinition != null);
       this.TraverseChildren((ITypeDefinitionMember)fieldDefinition);
       if (this.stopTraversal) return;
       if (fieldDefinition.IsCompileTimeConstant) {
     this.Traverse(fieldDefinition.CompileTimeValue);
     if (this.stopTraversal) return;
       }
       if (fieldDefinition.IsModified) {
     this.Traverse(fieldDefinition.CustomModifiers);
     if (this.stopTraversal) return;
       }
       if (fieldDefinition.IsMarshalledExplicitly) {
     this.Traverse(fieldDefinition.MarshallingInformation);
     if (this.stopTraversal) return;
       }
       this.Traverse(fieldDefinition.Type);
 }