/// <summary>
        /// Called when the user is accessing a protected or private member on a get.
        /// 
        /// The default implementation allows access to the fields or properties using reflection.
        /// </summary>
        public virtual ErrorInfo MakeNonPublicMemberGetError(OverloadResolverFactory resolverFactory, MemberTracker member, Type type, DynamicMetaObject instance) {
            switch (member.MemberType) {
                case TrackerTypes.Field:
                    FieldTracker ft = (FieldTracker)member;

                    return ErrorInfo.FromValueNoError(
                        Ast.Call(
                            AstUtils.Convert(AstUtils.Constant(ft.Field), typeof(FieldInfo)),
                            typeof(FieldInfo).GetMethod("GetValue"),
                            AstUtils.Convert(instance.Expression, typeof(object))
                        )
                    );
                case TrackerTypes.Property:
                    PropertyTracker pt = (PropertyTracker)member;

                    return ErrorInfo.FromValueNoError(
                        MemberTracker.FromMemberInfo(pt.GetGetMethod(true)).Call(resolverFactory, this, instance).Expression
                    );
                default:
                    throw new InvalidOperationException();
            }
        }

        private void MakeGenericBodyWorker(GetMemberInfo getMemInfo, Type type, MemberTracker tracker, Expression instance) {
            if (instance != null) {
                tracker = tracker.BindToInstance(instance);
            }

            Expression val = tracker.GetValue(getMemInfo.CodeContext, this, type);

            if (val != null) {
                getMemInfo.Body.FinishCondition(val);
            } else {
                ErrorInfo ei = tracker.GetError(this);
                if (ei.Kind != ErrorInfoKind.Success && getMemInfo.IsNoThrow) {
                    getMemInfo.Body.FinishCondition(MakeOperationFailed());
                } else {
                    getMemInfo.Body.FinishCondition(MakeError(tracker.GetError(this), typeof(object)));
                }
            }
        }

 private static bool IsTrackerApplicableForType(Type type, MemberTracker mt) {
     return mt.DeclaringType == type || type.IsSubclassOf(mt.DeclaringType);
 }

        /// <summary>
        /// Provides an opportunity for languages to replace all MemberTracker's with their own type.
        /// 
        /// Alternatlely a language can expose MemberTracker's directly.
        /// </summary>
        /// <param name="memberTracker">The member which is being returned to the user.</param>
        /// <param name="type">Tthe type which the memberTrack was accessed from</param>
        /// <returns></returns>
        public virtual DynamicMetaObject ReturnMemberTracker(Type type, MemberTracker memberTracker) {
            if (memberTracker.MemberType == TrackerTypes.Bound) {
                BoundMemberTracker bmt = (BoundMemberTracker)memberTracker;
                return new DynamicMetaObject(
                    Expression.New(
                        typeof(BoundMemberTracker).GetConstructor(new[] { typeof(MemberTracker), typeof(object) }),
                        AstUtils.Constant(bmt.BoundTo),
                        bmt.Instance.Expression
                    ),
                    BindingRestrictions.Empty
                );
            }

            return new DynamicMetaObject(AstUtils.Constant(memberTracker), BindingRestrictions.Empty, memberTracker);
        }

        public bool TryGetValue(SymbolId name, out MemberTracker value) {
            lock (_topPackage.HierarchyLock) {
                LoadNamespaces();

                if (_dict.TryGetValue(SymbolTable.IdToString(name), out value)) {
                    return true;
                }

                MemberTracker existingTypeEntity = null;
                string nameString = SymbolTable.IdToString(name);

                if (nameString.IndexOf(Type.Delimiter) != -1) {
                    value = null;
                    return false;
                }

                // Look up the type names and load the type if its name exists

                foreach (KeyValuePair<Assembly, TypeNames> kvp in _typeNames) {
                    if (!kvp.Value.Contains(nameString)) {
                        continue;
                    }

                    existingTypeEntity = kvp.Value.UpdateTypeEntity((TypeTracker)existingTypeEntity, nameString);
                }

                if (existingTypeEntity == null) {
                    existingTypeEntity = CheckForUnlistedType(nameString);
                }

                if (existingTypeEntity != null) {
                    _dict[SymbolTable.IdToString(name)] = existingTypeEntity;
                    value = existingTypeEntity;
                    return true;
                }

                return false;
            }
        }

            public override MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, OldDynamicAction/*!*/ action, Type/*!*/ type, string/*!*/ name) {
                foreach (Type t in binder.GetContributingTypes(type)) {
                    MemberGroup res = new MemberGroup(ArrayUtils.FindAll(t.GetMember(name, BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy), ProtectedOnly));

                    for (int i = 0; i < res.Count; i++) {
                        MethodTracker meth = res[i] as MethodTracker;                        
                        if (meth == null) {
                            continue;
                        }

                        if (meth.Name == "Finalize" && meth.Method.GetBaseDefinition() == typeof(object).GetMethod("Finalize", BindingFlags.NonPublic | BindingFlags.Instance)) {
                            MemberTracker[] retained = new MemberTracker[res.Count - 1];
                            if (res.Count == 1) {
                                res = MemberGroup.EmptyGroup;
                            } else {
                                for (int j = 0; j < i; j++) {
                                    retained[j] = res[j];
                                }
                                for (int j = i + 1; j < res.Count; j++) {
                                    retained[j - 1] = res[j];
                                }
                                res = new MemberGroup(retained);
                            }
                            break;
                        }
                    }
                    res = FilterSpecialNames(res, name, action);

                    return GetBaseHelperOverloads(PythonTypeOps.GetFinalSystemType(type), name, res);
                }

                return MemberGroup.EmptyGroup;
            }

        private static Expression ReturnMemberTracker(Type type, MemberTracker memberTracker, bool privateBinding) {
            switch (memberTracker.MemberType) {
                case TrackerTypes.TypeGroup:
                    return Ast.Constant(memberTracker);
                case TrackerTypes.Type:
                    return ReturnTypeTracker((TypeTracker)memberTracker);
                case TrackerTypes.Bound:
                    return ReturnBoundTracker((BoundMemberTracker)memberTracker, privateBinding);
                case TrackerTypes.Property:
                    return ReturnPropertyTracker((PropertyTracker)memberTracker, privateBinding);
                case TrackerTypes.Event:
                    return Ast.Call(
                        typeof(PythonOps).GetMethod("MakeBoundEvent"),
                        Ast.Constant(PythonTypeOps.GetReflectedEvent((EventTracker)memberTracker)),
                        Ast.Constant(null),
                        Ast.Constant(type)
                    );
                case TrackerTypes.Field:
                    return ReturnFieldTracker((FieldTracker)memberTracker);
                case TrackerTypes.MethodGroup:
                    return ReturnMethodGroup((MethodGroup)memberTracker);
                case TrackerTypes.Constructor:
                    MethodBase[] ctors = CompilerHelpers.GetConstructors(type, privateBinding, true);
                    object val;
                    if (PythonTypeOps.IsDefaultNew(ctors)) {
                        if (IsPythonType(type)) {
                            val = InstanceOps.New;
                        } else {
                            val = InstanceOps.NewCls;
                        }
                    } else {
                        val = PythonTypeOps.GetConstructor(type, InstanceOps.NonDefaultNewInst, ctors);
                    }

                    return Ast.Constant(val);
                case TrackerTypes.Custom:
                    return Ast.Constant(((PythonCustomTracker)memberTracker).GetSlot(), typeof(PythonTypeSlot));
            }
            return null;
        }

 public override ErrorInfo/*!*/ MakeStaticAssignFromDerivedTypeError(Type accessingType, MemberTracker info, Expression assignedValue, Expression context) {
     return MakeMissingMemberError(accessingType, info.Name);
 }

        /// <summary>
        /// Provides an opportunity for languages to replace all MemberInfo's with their own type.
        /// 
        /// Alternatlely a language can expose MemberInfo's directly.
        /// </summary>
        /// <param name="memberTracker">The member which is being returned to the user.</param>
        /// <param name="type">Tthe type which the memberTrack was accessed from</param>
        /// <returns></returns>
        public virtual Expression ReturnMemberTracker(Type type, MemberTracker memberTracker) {
            if (memberTracker.MemberType == TrackerTypes.Bound) {
                BoundMemberTracker bmt = (BoundMemberTracker)memberTracker;
                return Expression.New(
                    typeof(BoundMemberTracker).GetConstructor(new Type[] { typeof(MemberTracker), typeof(object) }),
                    AstUtils.Constant(bmt.BoundTo),
                    bmt.Instance);
            }

            return AstUtils.Constant(memberTracker);
        }

 public BoundMemberTracker(MemberTracker tracker, object instance) {
     _tracker = tracker;
     _objInst = instance;
 }

        private void MakeGenericBody(SetOrDeleteMemberInfo memInfo, DynamicMetaObject instance, DynamicMetaObject target, Type type, MemberTracker tracker, DynamicMetaObject errorSuggestion) {
            if (instance != null) {
                tracker = tracker.BindToInstance(instance);
            }

            DynamicMetaObject val = tracker.SetValue(memInfo.ResolutionFactory, this, type, target, errorSuggestion);

            if (val != null) {
                memInfo.Body.FinishCondition(val);
            } else {
                memInfo.Body.FinishCondition(
                    MakeError(tracker.GetError(this), typeof(object))
                );
            }
        }

        private bool IsProtectedSetter(MemberTracker mt) {
            PropertyTracker pt = mt as PropertyTracker;
            if (pt != null) {
                MethodInfo mi = pt.GetSetMethod(true);
                if (mi != null && (mi.IsFamily || mi.IsFamilyOrAssembly)) {
                    return true;
                }
            }

            FieldTracker ft = mt as FieldTracker;
            if (ft != null) {
                return ft.Field.IsFamily || ft.Field.IsFamilyOrAssembly;
            }

            return false;
        }

 public BoundMemberTracker(MemberTracker tracker, Expression instance) {
     _tracker = tracker;
     _instance = instance;
 }

        private void MakeGenericBodyWorker(GetMemberInfo getMemInfo, Type type, MemberTracker tracker, DynamicMetaObject instance) {
            if (instance != null) {
                tracker = tracker.BindToInstance(instance);
            }

            DynamicMetaObject val = tracker.GetValue(getMemInfo.ResolutionFactory, this, type);

            if (val != null) {
                getMemInfo.Body.FinishCondition(val);
            } else {
                ErrorInfo ei = tracker.GetError(this);
                if (ei.Kind != ErrorInfoKind.Success && getMemInfo.IsNoThrow) {
                    getMemInfo.Body.FinishError(MakeOperationFailed());
                } else {
                    getMemInfo.Body.FinishError(MakeError(tracker.GetError(this), typeof(object)));
                }
            }
        }

            public override MemberGroup/*!*/ ResolveMember(MemberBinder/*!*/ binder, MemberRequestKind/*!*/ action, Type/*!*/ type, string/*!*/ name) {
                foreach (Type t in binder.GetContributingTypes(type)) {
                    MemberGroup res = new MemberGroup(
                        t.GetMember(name, BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
                        .Where(ProtectedOnly)
                        .ToArray());

                    for (int i = 0; i < res.Count; i++) {
                        MethodTracker meth = res[i] as MethodTracker;                        
                        if (meth == null) {
                            continue;
                        }

                        if (meth.Name == "Finalize" && meth.Method.GetBaseDefinition() == typeof(object).GetMethod("Finalize", BindingFlags.NonPublic | BindingFlags.Instance)) {
                            MemberTracker[] retained = new MemberTracker[res.Count - 1];
                            if (res.Count == 1) {
                                res = MemberGroup.EmptyGroup;
                            } else {
                                for (int j = 0; j < i; j++) {
                                    retained[j] = res[j];
                                }
                                for (int j = i + 1; j < res.Count; j++) {
                                    retained[j - 1] = res[j];
                                }
                                res = new MemberGroup(retained);
                            }
                            break;
                        }
                    }
                    return FilterSpecialNames(res, name, action);
                }

                return MemberGroup.EmptyGroup;
            }

        public override ErrorInfo/*!*/ MakeNonPublicMemberGetError(Expression codeContext, MemberTracker member, Type type, Expression instance) {
            if (PrivateBinding) {
                return base.MakeNonPublicMemberGetError(codeContext, member, type, instance);
            }

            return ErrorInfo.FromValue(
                BindingHelpers.TypeErrorForProtectedMember(type, member.Name)
            );
        }

        private void MakeGenericBodyWorker(GetMemberInfo getMemInfo, Type type, MemberTracker tracker, Expression instance) {
            if (instance != null) {
                tracker = tracker.BindToInstance(instance);
            }

            Expression val = tracker.GetValue(getMemInfo.CodeContext, this, type);

            getMemInfo.Body.FinishCondition(
                val != null ?
                    val :
                    MakeError(tracker.GetError(this))
            );
        }

 public virtual ErrorInfo MakeContainsGenericParametersError(MemberTracker tracker) {
     return ErrorInfo.FromException(
         Expression.New(
             typeof(InvalidOperationException).GetConstructor(new[] { typeof(string) }),
             AstUtils.Constant(Strings.InvalidOperation_ContainsGenericParameters(tracker.DeclaringType.Name, tracker.Name))
         )
     );
 }

 public virtual ErrorInfo MakeGenericAccessError(MemberTracker info) {
     return ErrorInfo.FromException(
         Expression.New(
             typeof(MemberAccessException).GetConstructor(new[] { typeof(string) }),
             AstUtils.Constant(info.Name)
         )
     );
 }

 /// <summary>
 /// Called when a set is attempting to assign to a field or property from a derived class through the base class.
 /// 
 /// The default behavior is to allow the assignment.
 /// </summary>
 public virtual ErrorInfo MakeStaticAssignFromDerivedTypeError(Type accessingType, DynamicMetaObject self, MemberTracker assigning, DynamicMetaObject assignedValue, OverloadResolverFactory context) {
     switch (assigning.MemberType) {
         case TrackerTypes.Property:
             PropertyTracker pt = (PropertyTracker)assigning;
             MethodInfo setter = pt.GetSetMethod() ?? pt.GetSetMethod(true);
             return ErrorInfo.FromValueNoError(
                 AstUtils.SimpleCallHelper(
                     setter,
                     ConvertExpression(
                         assignedValue.Expression,
                         setter.GetParameters()[0].ParameterType,
                         ConversionResultKind.ExplicitCast,
                         context
                     )
                 )
             );
         case TrackerTypes.Field:
             FieldTracker ft = (FieldTracker)assigning;
             return ErrorInfo.FromValueNoError(
                 Expression.Assign(
                     Expression.Field(null, ft.Field),
                     ConvertExpression(assignedValue.Expression, ft.FieldType, ConversionResultKind.ExplicitCast, context)
                 )
             );
         default:
             throw new InvalidOperationException();
     }
 }