public FieldValueReference(
            EvaluationContext ctx,
            FieldInfo field,
            object obj,
            Type declaringType,
            string vname,
            ObjectValueFlags vflags,
            FieldReferenceBatch batch = null) : base(ctx)
        {
            this.field         = field;
            this.obj           = obj;
            this.declaringType = declaringType;
            this.vname         = vname;
            this.batch         = batch;

            if (field.IsStatic)
            {
                this.obj = null;
            }

            flags = GetFlags(field);

            // if `vflags` already has an origin specified, we need to unset the `Field` flag which is always returned by GetFlags().
            if ((vflags & ObjectValueFlags.OriginMask) != 0)
            {
                flags &= ~ObjectValueFlags.Field;
            }

            flags |= vflags;

            if (obj?.GetType()?.IsPrimitive == true)
            {
                flags |= ObjectValueFlags.ReadOnly;
            }
        }
Пример #2
0
        public FieldValueReference(EvaluationContext ctx, FieldInfoMirror field, object obj, TypeMirror declaringType, string vname, ObjectValueFlags vflags, FieldReferenceBatch batch = null) : base(ctx)
        {
            this.field         = field;
            this.obj           = obj;
            this.declaringType = declaringType;
            this.vname         = vname;
            this.batch         = batch;
            flags = vflags;

            if (field.IsStatic)
            {
                this.obj = null;
            }

            var objectMirror = obj as ObjectMirror;

            if (objectMirror != null)
            {
                EnsureContextHasDomain(objectMirror.Domain);
            }

            flags |= GetFlags(field);

            if (obj is PrimitiveValue)
            {
                flags |= ObjectValueFlags.ReadOnly;
            }
        }
 public FieldValueReference(
     EvaluationContext ctx,
     FieldInfo field,
     object obj,
     Type declaringType,
     FieldReferenceBatch batch = null)
     : this(ctx, field, obj, declaringType, null, ObjectValueFlags.Field, batch)
 {
 }
		public FieldValueReference (EvaluationContext ctx, FieldInfoMirror field, object obj, TypeMirror declaringType, string vname, ObjectValueFlags vflags, FieldReferenceBatch batch = null): base (ctx)
		{
			this.field = field;
			this.obj = obj;
			this.declaringType = declaringType;
			this.vname = vname;
			this.batch = batch;
			flags = vflags;

			if (field.IsStatic)
				this.obj = null;

			var objectMirror = obj as ObjectMirror;
			if (objectMirror != null)
				EnsureContextHasDomain (objectMirror.Domain);

			flags |= GetFlags (field);

			if (obj is PrimitiveValue)
				flags |= ObjectValueFlags.ReadOnly;
		}
Пример #5
0
        public IEnumerable <ValueReference> GetMembers(
            EvaluationContext ctx,
            IObjectSource objectSource,
            object t,
            object value,
            BindingFlags bindingFlags)
        {
            var  subProps = new Dictionary <string, PropertyInfo> ();
            var  type     = t as Type;
            Type realType = null;

            if (value != null && (bindingFlags & BindingFlags.Instance) != 0)
            {
                realType = GetValueType(value) as Type;
            }

            // First of all, get a list of properties overridden in sub-types
            while (realType != null && realType != type)
            {
                foreach (PropertyInfo property in realType.GetProperties(bindingFlags | BindingFlags.DeclaredOnly))
                {
                    MethodInfo method = property.GetGetMethod(true);

                    if (method == null || method.GetParameters().Length != 0 || method.IsAbstract || !method.IsVirtual || method.IsStatic)
                    {
                        continue;
                    }

                    if (method.IsPublic && ((bindingFlags & BindingFlags.Public) == 0))
                    {
                        continue;
                    }

                    if (!method.IsPublic && ((bindingFlags & BindingFlags.NonPublic) == 0))
                    {
                        continue;
                    }

                    subProps[property.Name] = property;
                }

                realType = realType.BaseType;
            }

            var  tupleNames           = GetTupleElementNames(objectSource, ctx);
            bool hasExplicitInterface = false;

            while (type != null)
            {
                var fieldsBatch = new FieldReferenceBatch(value);
                foreach (var field in type.GetFields(bindingFlags))
                {
                    if (field.IsStatic)
                    {
                        yield return(new FieldValueReference(ctx, field, value, type));
                    }
                    else
                    {
                        fieldsBatch.Add(field);
                        string vname = MapTupleName(field.Name, tupleNames);
                        yield return(new FieldValueReference(ctx, field, value, type, vname, ObjectValueFlags.Field, fieldsBatch));
                    }
                }

                foreach (var prop in type.GetProperties(bindingFlags))
                {
                    var getter = prop.GetGetMethod(true);

                    if (getter == null || getter.GetParameters().Length != 0 || getter.IsAbstract)
                    {
                        continue;
                    }

                    if (getter.IsStatic && ((bindingFlags & BindingFlags.Static) == 0))
                    {
                        continue;
                    }

                    if (!getter.IsStatic && ((bindingFlags & BindingFlags.Instance) == 0))
                    {
                        continue;
                    }

                    if (getter.IsPublic && ((bindingFlags & BindingFlags.Public) == 0))
                    {
                        continue;
                    }

                    //This is only possible in case of explicitly implemented interface property, which we handle later
                    if (getter.IsVirtual && getter.IsPrivate)
                    {
                        hasExplicitInterface = true;
                        continue;
                    }

                    if (!getter.IsPublic && ((bindingFlags & BindingFlags.NonPublic) == 0))
                    {
                        continue;
                    }

                    // If a property is overriden, return the override instead of the base property
                    PropertyInfo overridden;
                    if (getter.IsVirtual && subProps.TryGetValue(prop.Name, out overridden))
                    {
                        getter = overridden.GetGetMethod(true);
                        if (getter == null)
                        {
                            continue;
                        }

                        yield return(new PropertyValueReference(ctx, overridden, value, overridden.DeclaringType, getter, null));
                    }
                    else
                    {
                        yield return(new PropertyValueReference(ctx, prop, value, type, getter, null));
                    }
                }

                if ((bindingFlags & BindingFlags.DeclaredOnly) != 0)
                {
                    break;
                }

                type = type.BaseType;
            }

            type = t as Type;
            if (type == null ||
                !hasExplicitInterface ||
                (bindingFlags & BindingFlags.Instance) == 0 ||
                (bindingFlags & BindingFlags.Public) == 0)
            {
                yield break;
            }

            var interfaces = type.GetInterfaces();

            foreach (Type intr in interfaces)
            {
                var map = type.GetInterfaceMap(intr);
                foreach (PropertyInfo prop in intr.GetProperties(bindingFlags))
                {
                    var getter = prop.GetGetMethod(true);
                    if (getter == null || getter.GetParameters().Length != 0)
                    {
                        continue;
                    }
                    var implementationGetter = map.TargetMethods[Array.IndexOf(map.InterfaceMethods, getter)];
                    //We are only intersted into private(explicit) implementations because public ones are already handled before
                    if (implementationGetter.IsPublic)
                    {
                        continue;
                    }
                    yield return(new PropertyValueReference(ctx, prop, value, type, getter, null));
                }
            }
        }
 public FieldValueReference(EvaluationContext ctx, FieldInfoMirror field, object obj, TypeMirror declaringType, FieldReferenceBatch batch = null)
     : this(ctx, field, obj, declaringType, null, ObjectValueFlags.Field, batch)
 {
 }