public override ValueReference GetIndexerReference(EvaluationContext ctx, object target, object[] indices)
        {
            TypeMirror targetType = GetValueType(ctx, target) as TypeMirror;

            Value[]      values = new Value [indices.Length];
            TypeMirror[] types  = new TypeMirror [indices.Length];
            for (int n = 0; n < indices.Length; n++)
            {
                types [n]  = ToTypeMirror(ctx, GetValueType(ctx, indices [n]));
                values [n] = (Value)indices [n];
            }

            List <MethodMirror>       candidates = new List <MethodMirror> ();
            List <PropertyInfoMirror> props      = new List <PropertyInfoMirror> ();

            TypeMirror type = targetType;

            while (type != null)
            {
                foreach (PropertyInfoMirror prop in type.GetProperties())
                {
                    MethodMirror met = prop.GetGetMethod(true);
                    if (met != null && !met.IsStatic && met.GetParameters().Length > 0)
                    {
                        candidates.Add(met);
                        props.Add(prop);
                    }
                }
                type = type.BaseType;
            }
            MethodMirror idx = OverloadResolve((SoftEvaluationContext)ctx, targetType.Name, null, types, candidates, true);
            int          i   = candidates.IndexOf(idx);

            return(new PropertyValueReference(ctx, props[i], target, null, values));
        }
        public ExpandedProperty(TypeMirror typeMirror, StackFrame frame, LocalVariable localVariable)
        {
            this.frame         = frame;
            this.localVariable = localVariable;
            var properties = typeMirror.GetProperties().Cast <Mirror>();
            var methods    = typeMirror.GetMethods().Cast <Mirror>();
            var fields     = typeMirror.GetFields().Cast <Mirror>();
            var children   = properties.Concat(methods).Concat(fields);

            allProperties = children.ToList();
        }
        private static List <KeyValuePair <string, Mirror> > GetChildren(TypeMirror type, Guid filterGuid)
        {
            var children = new List <KeyValuePair <string, Mirror> >();

            do
            {
                if (filterGuid != EnumOnlyPropertiesFilter)
                {
                    children.AddRange(type.GetFields().Select(x => new KeyValuePair <string, Mirror>(x.Name, x)));
                }
                if (filterGuid != EnumOnlyFieldsFilter)
                {
                    children.AddRange(type.GetProperties().Select(x => new KeyValuePair <string, Mirror>(x.Name, x)));
                }

                type = type.BaseType;
            } while (type != null);

            children = children.Where(x => x.Key != null && x.Key.Length > 0 && x.Key[0] != '<').OrderBy(x => x.Key).ToList();
            return(children);
        }
        protected override TypeDisplayData OnGetTypeDisplayData(EvaluationContext gctx, object type)
        {
            SoftEvaluationContext ctx = (SoftEvaluationContext)gctx;
            TypeDisplayData       td  = new TypeDisplayData();

            try {
                TypeMirror t = (TypeMirror)type;
                foreach (CustomAttributeDataMirror attr in t.GetCustomAttributes(true))
                {
                    string attName = attr.Constructor.DeclaringType.FullName;
                    if (attName == "System.Diagnostics.DebuggerDisplayAttribute")
                    {
                        DebuggerDisplayAttribute at = BuildAttribute <DebuggerDisplayAttribute> (attr);
                        td.NameDisplayString  = at.Name;
                        td.TypeDisplayString  = at.Type;
                        td.ValueDisplayString = at.Value;
                    }
                    else if (attName == "System.Diagnostics.DebuggerTypeProxyAttribute")
                    {
                        DebuggerTypeProxyAttribute at = BuildAttribute <DebuggerTypeProxyAttribute> (attr);
                        td.ProxyType = at.ProxyTypeName;
                        if (!string.IsNullOrEmpty(td.ProxyType))
                        {
                            ForceLoadType(ctx, td.ProxyType);
                        }
                    }
                }
                foreach (FieldInfoMirror fi in t.GetFields())
                {
                    CustomAttributeDataMirror[] attrs = fi.GetCustomAttributes(true);
                    DebuggerBrowsableAttribute  att   = GetAttribute <DebuggerBrowsableAttribute> (attrs);
                    if (att == null)
                    {
                        var cga = GetAttribute <System.Runtime.CompilerServices.CompilerGeneratedAttribute> (attrs);
                        if (cga != null)
                        {
                            att = new DebuggerBrowsableAttribute(DebuggerBrowsableState.Never);
                        }
                    }
                    if (att != null)
                    {
                        if (td.MemberData == null)
                        {
                            td.MemberData = new Dictionary <string, DebuggerBrowsableState> ();
                        }
                        td.MemberData [fi.Name] = att.State;
                    }
                }
                foreach (PropertyInfoMirror pi in t.GetProperties())
                {
                    DebuggerBrowsableAttribute att = GetAttribute <DebuggerBrowsableAttribute> (pi.GetCustomAttributes(true));
                    if (att != null)
                    {
                        if (td.MemberData == null)
                        {
                            td.MemberData = new Dictionary <string, DebuggerBrowsableState> ();
                        }
                        td.MemberData [pi.Name] = att.State;
                    }
                }
            } catch (Exception ex) {
                ctx.Session.WriteDebuggerOutput(true, ex.ToString());
            }
            return(td);
        }
        protected override IEnumerable <ValueReference> GetMembers(EvaluationContext ctx, object t, object co, BindingFlags bindingFlags)
        {
            Dictionary <string, PropertyInfoMirror> subProps = new Dictionary <string, PropertyInfoMirror> ();
            TypeMirror type     = t as TypeMirror;
            TypeMirror realType = null;

            if (co != null && (bindingFlags & BindingFlags.Instance) != 0)
            {
                realType = GetValueType(ctx, co) as TypeMirror;
            }

            // First of all, get a list of properties overriden in sub-types
            while (realType != null && realType != type)
            {
                foreach (PropertyInfoMirror prop in realType.GetProperties(bindingFlags | BindingFlags.DeclaredOnly))
                {
                    MethodMirror met = prop.GetGetMethod(true);
                    if (met == null || met.GetParameters().Length != 0 || met.IsAbstract || !met.IsVirtual || met.IsStatic)
                    {
                        continue;
                    }
                    if (met.IsPublic && ((bindingFlags & BindingFlags.Public) == 0))
                    {
                        continue;
                    }
                    if (!met.IsPublic && ((bindingFlags & BindingFlags.NonPublic) == 0))
                    {
                        continue;
                    }
                    subProps [prop.Name] = prop;
                }
                realType = realType.BaseType;
            }

            while (type != null)
            {
                foreach (FieldInfoMirror field in type.GetFields())
                {
                    if (field.IsStatic && ((bindingFlags & BindingFlags.Static) == 0))
                    {
                        continue;
                    }
                    if (!field.IsStatic && ((bindingFlags & BindingFlags.Instance) == 0))
                    {
                        continue;
                    }
                    if (field.IsPublic && ((bindingFlags & BindingFlags.Public) == 0))
                    {
                        continue;
                    }
                    if (!field.IsPublic && ((bindingFlags & BindingFlags.NonPublic) == 0))
                    {
                        continue;
                    }
                    yield return(new FieldValueReference(ctx, field, co, type));
                }
                foreach (PropertyInfoMirror prop in type.GetProperties(bindingFlags))
                {
                    MethodMirror met = prop.GetGetMethod(true);
                    if (met == null || met.GetParameters().Length != 0 || met.IsAbstract)
                    {
                        continue;
                    }
                    if (met.IsStatic && ((bindingFlags & BindingFlags.Static) == 0))
                    {
                        continue;
                    }
                    if (!met.IsStatic && ((bindingFlags & BindingFlags.Instance) == 0))
                    {
                        continue;
                    }
                    if (met.IsPublic && ((bindingFlags & BindingFlags.Public) == 0))
                    {
                        continue;
                    }
                    if (!met.IsPublic && ((bindingFlags & BindingFlags.NonPublic) == 0))
                    {
                        continue;
                    }

                    // If a property is overriden, return the override instead of the base property
                    PropertyInfoMirror overriden;
                    if (met.IsVirtual && subProps.TryGetValue(prop.Name, out overriden))
                    {
                        yield return(new PropertyValueReference(ctx, overriden, co, overriden.DeclaringType, null));
                    }
                    else
                    {
                        yield return(new PropertyValueReference(ctx, prop, co, type, null));
                    }
                }
                if ((bindingFlags & BindingFlags.DeclaredOnly) != 0)
                {
                    break;
                }
                type = type.BaseType;
            }
        }