public virtual PropertyInfo GetDeclaredProperty()

in tools/AutoMapper/ReflectionExtensions.cs [188:279]
72 lines of code
8 McCabe index (conditional complexity)

        public virtual PropertyInfo GetDeclaredProperty(string name) =>
            _type.GetProperty(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

        public virtual object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) =>
            _type.InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);

        public virtual ConstructorInfo[] GetConstructors(BindingFlags bindingAttr) =>
            _type.GetConstructors(bindingAttr);

        public virtual MethodInfo[] GetMethods(BindingFlags bindingAttr) =>
            _type.GetMethods(bindingAttr);

        public virtual FieldInfo GetField(string name, BindingFlags bindingAttr) =>
            _type.GetField(name, bindingAttr);

        public virtual FieldInfo[] GetFields(BindingFlags bindingAttr) =>
            _type.GetFields(bindingAttr);

        public virtual Type GetInterface(string name, bool ignoreCase) =>
            _type.GetInterface(name, ignoreCase);

        public virtual Type[] GetInterfaces() =>
            _type.GetInterfaces();

        public virtual EventInfo GetEvent(string name, BindingFlags bindingAttr) =>
            _type.GetEvent(name, bindingAttr);

        public virtual EventInfo[] GetEvents(BindingFlags bindingAttr) =>
            _type.GetEvents(bindingAttr);

        public virtual PropertyInfo[] GetProperties(BindingFlags bindingAttr) =>
            _type.GetProperties(bindingAttr);

        public virtual Type[] GetNestedTypes(BindingFlags bindingAttr) =>
            _type.GetNestedTypes(bindingAttr);

        public virtual Type GetNestedType(string name, BindingFlags bindingAttr) =>
            _type.GetNestedType(name, bindingAttr);

        public virtual MemberInfo[] GetMembers(BindingFlags bindingAttr) =>
            _type.GetMembers(bindingAttr);

        public virtual Type GetElementType() =>
            _type.GetElementType();

        public virtual object[] GetCustomAttributes(bool inherit) =>
            _type.GetCustomAttributes(inherit);

        public virtual object[] GetCustomAttributes(Type attributeType, bool inherit) =>
            _type.GetCustomAttributes(attributeType, inherit);

        public virtual bool IsDefined(Type attributeType, bool inherit) =>
            _type.IsDefined(attributeType, inherit);

        public virtual bool IsSubclassOf(Type c) =>
            _type.IsSubclassOf(c);

        public virtual Type[] GetGenericParameterConstraints() =>
            _type.GetGenericParameterConstraints();

        public virtual bool IsAssignableFrom(TypeInfo typeInfo)
        {
            if (typeInfo == null)
            {
                return false;
            }
            if (this == typeInfo)
            {
                return true;
            }
            if (typeInfo.IsSubclassOf(_type))
            {
                return true;
            }
            if (IsInterface)
            {
                return typeInfo._type.ImplementInterface(_type);
            }
            if (this.IsGenericParameter)
            {
                Type[] genericParameterConstraints = this.GetGenericParameterConstraints();
                for (int i = 0; i < genericParameterConstraints.Length; i++)
                {
                    if (!genericParameterConstraints[i].IsAssignableFrom(typeInfo._type))
                    {
                        return false;
                    }
                }
                return true;
            }
            return false;
        }