internal override AnalysisValue UnionMergeTypes(AnalysisValue av, int strength) {
            if (strength >= MergeStrength.ToBaseClass) {
                return _analyzer._zeroIntValue;
            }

            return base.UnionMergeTypes(av, strength);
        }

        internal override AnalysisValue UnionMergeTypes(AnalysisValue av, int strength) {
            if (strength >= StringUnionStrength) {
                return _analyzer._emptyStringValue;
            }

            return base.UnionMergeTypes(av, strength);
        }

 private static string GetInstanceShortDescription(AnalysisValue ns) {
     var bci = ns as BuiltinClassInfo;
     if (bci != null) {
         return bci.Instance.ShortDescription;
     }
     return ns.ShortDescription;
 }

 internal override bool UnionEquals(AnalysisValue ns, int strength) {
     var tns = ns as TestNamespace;
     if (tns == null) {
         return false;
     }
     return Name.Equals(tns.Name);
 }

 internal override AnalysisValue UnionMergeTypes(AnalysisValue ns, int strength) {
     var tns = ns as TestNamespace;
     if (tns == null || object.ReferenceEquals(this, tns)) {
         return this;
     }
     return new TestNamespace { _name = Name, Value = MergeCount > tns.MergeCount ? Value : tns.Value, MergeCount = MergeCount + tns.MergeCount };
 }

        public ObjectValue(ProjectEntry projectEntry, AnalysisValue prototype = null, string description = null)
            : base(projectEntry) {
            if (prototype != null) {
                Add("__proto__", prototype.SelfSet);
            }
#if DEBUG
            _description = description;
#endif
        }

 protected InterpreterScope(AnalysisValue av, InterpreterScope cloned, bool isCloned) {
     Debug.Assert(isCloned);
     _av = av;
     Children.AddRange(cloned.Children);
     _nodeScopes = cloned._nodeScopes;
     _nodeValues = cloned._nodeValues;
     _variables = cloned._variables;
     _linkedVariables = cloned._linkedVariables;
 }

        internal override AnalysisValue UnionMergeTypes(AnalysisValue ns, int strength) {
            if (strength >= MergeStrength.ToObject) {
                if (ns is InstanceValue) {
                    return ProjectState._immutableObject;
                }
            }

            return base.UnionMergeTypes(ns, strength);
        }

        internal override bool UnionEquals(AnalysisValue ns, int strength) {
            if (strength >= MergeStrength.ToObject) {
                if (ns is InstanceValue) {
                    return true;
                }
            }

            return base.UnionEquals(ns, strength);
        }

        internal static bool PushProtoLookup(AnalysisValue value){
            if (_hitCount == null) {
                _hitCount = new Dictionary<AnalysisValue, int>();
            }

            int count;
            if (!_hitCount.TryGetValue(value, out count)) {
                _hitCount[value] = 1;
                return true;
            } else {
                _hitCount[value] = count + 1;
            }
            return false;
        }

        internal override AnalysisValue UnionMergeTypes(AnalysisValue av, int strength) {
            if (strength >= MergeStrength.ToBaseClass) {
                var literal = av as ObjectLiteralValue;
                if (literal != null) {
                    return this;
                }
            }
            
            if (strength >= MergeStrength.ToBaseClass) {
                var literal = av as ObjectLiteralValue;
                if (literal != null && literal._node == _node) {
                    return this;
                }
            }

            return base.UnionMergeTypes(av, strength);
        }

        internal override bool UnionEquals(AnalysisValue av, int strength) {
            if (strength >= MergeStrength.ToBaseClass) {
                var literal = av as ObjectLiteralValue;
                if (literal != null) {
                    return true;
                }
            }

            if (strength >= MergeStrength.ToBaseClass) {
                var literal = av as ObjectLiteralValue;
                if (literal != null) {
                    // two literals from the same node, these
                    // literals were created by independent function
                    // analysis, merge them together now.
                    return literal._node == _node;
                }
            }
            return base.UnionEquals(av, strength);
        }

        /// <summary>
        /// Get Test Case Members for a class.  If the class has 'test*' tests 
        /// return those.  If there aren't any 'test*' tests return (if one at 
        /// all) the runTest overridden method
        /// </summary>
        private static IEnumerable<KeyValuePair<string, IAnalysisSet>> GetTestCaseMembers(
            ModuleAnalysis analysis,
            AnalysisValue classValue
        ) {
            var methodFunctions = classValue.GetAllMembers(analysis.InterpreterContext)
                .Where(v => v.Value.Any(m => m.MemberType == PythonMemberType.Function || m.MemberType == PythonMemberType.Method));

            var tests = methodFunctions.Where(v => v.Key.StartsWith("test"));
            var runTest = methodFunctions.Where(v => v.Key.Equals("runTest"));

            if (tests.Any()) {
                return tests;
            } else {
                return runTest;
            }
        }

 internal override bool UnionEquals(AnalysisValue ns, int strength) {
     if (strength < MergeStrength.IgnoreIterableNode) {
         if (ns == ProjectState.ClassInfos[BuiltinTypeId.Dict].Instance) {
             return true;
         }
         var ci = ns as ConstantInfo;
         if (ci != null && ci.ClassInfo == ProjectState.ClassInfos[BuiltinTypeId.Dict]) {
             return true;
         }
         var di = ns as DictionaryInfo;
         if (di != null) {
             return di._node.Equals(_node);
         }
         return false;
     }
     return base.UnionEquals(ns, strength);
 }

 private static bool IsTestCaseClass(AnalysisValue cls) {
     if (cls == null ||
         cls.DeclaringModule != null ||
         cls.PythonType == null ||
         cls.PythonType.DeclaringModule == null) {
         return false;
     }
     var mod = cls.PythonType.DeclaringModule.Name;
     return (mod == "unittest" || mod.StartsWith("unittest.")) && cls.Name == "TestCase";
 }

 internal override AnalysisValue UnionMergeTypes(AnalysisValue ns, int strength) {
     if (strength < MergeStrength.IgnoreIterableNode) {
         return ClassInfo.Instance;
     }
     return base.UnionMergeTypes(ns, strength);
 }

 internal static void PopProtoLookup(AnalysisValue value) {
     int count = _hitCount[value];
     if (count == 1) {
         _hitCount.Remove(value);
     } else {
         _hitCount[value] = count - 1;
     }
 }

        internal override bool UnionEquals(AnalysisValue ns, int strength) {
            if (strength >= MergeStrength.ToObject) {
                if (ns.TypeId == BuiltinTypeId.NoneType) {
                    // II + BII(None) => do not merge
                    return false;
                }

                // II + II => BII(object)
                // II + BII => BII(object)
                var obj = ProjectState.ClassInfos[BuiltinTypeId.Object];
                return ns is InstanceInfo || 
                    (ns is BuiltinInstanceInfo && ns.TypeId != BuiltinTypeId.Type && ns.TypeId != BuiltinTypeId.Function) ||
                    ns == obj.Instance;

            } else if (strength >= MergeStrength.ToBaseClass) {
                var ii = ns as InstanceInfo;
                if (ii != null) {
                    return ii.ClassInfo.UnionEquals(ClassInfo, strength);
                }
                var bii = ns as BuiltinInstanceInfo;
                if (bii != null) {
                    return bii.ClassInfo.UnionEquals(ClassInfo, strength);
                }
            }

            return base.UnionEquals(ns, strength);
        }

 private IAnalysisSet GetRecurse(AnalysisValue protoStart, Node node, AnalysisUnit unit, string name, bool addRef) {
     var prototypes = protoStart.GetPrototype(unit.ProjectEntry);
     IAnalysisSet protovalue = AnalysisSet.Empty;
     if (prototypes != null) {
         try {
             foreach (var proto in prototypes) {
                 if (PushProtoLookup(proto.Value)) {
                     var property = proto.Value.GetProperty(node, unit, name);
                     if (property != null) {
                         var value = property.GetValue(
                             node,
                             unit,
                             proto.Value.DeclaringModule,
                             this.SelfSet,
                             addRef
                         );
                         protovalue = protovalue.Union(value);
                         if (property.IsEphemeral) {
                             protovalue = protovalue.Union(GetRecurse(proto.Value, node, unit, name, addRef));
                         }
                     } else {
                         // keep searching the prototype chain...
                         protovalue = protovalue.Union(GetRecurse(proto.Value, node, unit, name, addRef));
                     }
                 }
             }
         } finally {
             foreach (var proto in prototypes) {
                 PopProtoLookup(proto.Value);
             }
         }
     }
    
     return protovalue;
 }

        internal override AnalysisValue UnionMergeTypes(AnalysisValue ns, int strength) {
            if (strength >= MergeStrength.ToObject) {
                // II + II => BII(object)
                // II + BII => BII(object)
                //return ProjectState.ClassInfos[BuiltinTypeId.Object].Instance;
#if FALSE
            } else if (strength >= MergeStrength.ToBaseClass) {
                var ii = ns as InstanceInfo;
                if (ii != null) {
                    return ii.ClassInfo.UnionMergeTypes(ClassInfo, strength).GetInstanceType().Single();
                }
                var bii = ns as BuiltinInstanceInfo;
                if (bii != null) {
                    return bii.ClassInfo.UnionMergeTypes(ClassInfo, strength).GetInstanceType().Single();
                }
#endif
            }

            return base.UnionMergeTypes(ns, strength);
        }