CodeTypeReference ConvTypeRef(TypeReference tr)
		{
			if (tr == null) return null;
			string name = tr.ToString();
			if (BooAmbience.ReverseTypeConversionTable.ContainsKey(name))
				name = BooAmbience.ReverseTypeConversionTable[name];
			return new CodeTypeReference(name);
		}

		static bool IsSameType(TypeReference a, TypeReference b, StringComparer nameComparer)
		{
			ArrayTypeReference arr1 = a as ArrayTypeReference;
			ArrayTypeReference arr2 = b as ArrayTypeReference;
			SimpleTypeReference s1 = a as SimpleTypeReference;
			SimpleTypeReference s2 = b as SimpleTypeReference;
			if (arr1 != null && arr2 != null) {
				if (arr1.Rank.Value != arr2.Rank.Value)
					return false;
				return IsSameType(arr1.ElementType, arr2.ElementType, nameComparer);
			} else if (s1 != null && s2 != null) {
				return nameComparer.Equals(s1.Name, s2.Name);
			} else {
				return false;
			}
		}

 public Method CreateRuntimeMethod(string name, TypeReference returnType)
 {
     Method method = CreateVirtualMethod(name, returnType);
     method.ImplementationFlags = MethodImplementationFlags.Runtime;
     return method;
 }

 void CheckParameterType(TypeReference type)
 {
     if (type.Entity != VoidType()) return;
     Error(CompilerErrorFactory.InvalidParameterType(type, VoidType()));
 }

		public Event(LexicalInfo lexicalInfo, string name, TypeReference type) : base(lexicalInfo)
		{
			this.Name = name;
			this.Type = type;
		}

 public Field(LexicalInfo lexicalInfo, TypeReference type, Expression initializer)
     : base(lexicalInfo)
 {
     this.Type = type;
     this.Initializer = initializer;
 }

 public Declaration(LexicalInfo token, string name, TypeReference type)
     : base(token)
 {
     this.Name = name;
     this.Type = type;
 }

 public override bool Replace(Node existing, Node newNode)
 {
     if (base.Replace(existing, newNode))
     {
         return true;
     }
     if (_type == existing)
     {
         this.Type = (TypeReference)newNode;
         return true;
     }
     return false;
 }

 void CheckParameterType(TypeReference type)
 {
     if (type.Entity != TypeSystemServices.VoidType) return;
     Error(CompilerErrorFactory.InvalidParameterType(type, type.Entity.ToString()));
 }

 bool CheckDeclarationType(TypeReference type)
 {
     if (type.Entity != TypeSystemServices.VoidType) return true;
     Error(CompilerErrorFactory.InvalidDeclarationType(type, type.Entity.ToString()));
     return false;
 }

 public ParameterDeclaration(string name, TypeReference type)
     : this(name, type, ParameterModifiers.None)
 {
 }

 public static CompilerError TypeConstraintConflictsWithSpecialConstraint(GenericParameterDeclaration gpd, TypeReference type, string constraint)
 {
     return Instantiate("BCE0161", type, gpd.Name, type, constraint);
 }

 public static CompilerError MultipleBaseTypeConstraints(GenericParameterDeclaration gpd, TypeReference type, TypeReference other)
 {
     return Instantiate("BCE0163", type, gpd.Name, type, other);
 }

 public static CompilerError InvalidTypeConstraint(GenericParameterDeclaration gpd, TypeReference type)
 {
     return Instantiate("BCE0162", type, gpd.Name, type);
 }

        void ResolveClassAbstractProperty(ClassDefinition node,
			TypeReference baseTypeRef,
			IProperty entity)
        {
            bool resolved = false;

            foreach (TypeMember member in node.Members)
            {
                if (entity.Name != member.Name
                    || NodeType.Property != member.NodeType
                    || !IsCorrectExplicitMemberImplOrNoExplicitMemberAtAll(member, entity)
                    || !TypeSystemServices.CheckOverrideSignature(entity.GetParameters(), GetPropertyEntity(member).GetParameters()))
                    continue;

                Property p = (Property) member;
                ProcessPropertyAccessor(p, p.Getter, entity.GetGetMethod());
                ProcessPropertyAccessor(p, p.Setter, entity.GetSetMethod());
                if (null == p.Type)
                {
                    p.Type = CodeBuilder.CreateTypeReference(entity.Type);
                }
                else
                {
                    if (entity.Type != p.Type.Entity)
                        Error(CompilerErrorFactory.ConflictWithInheritedMember(p, p.FullName, entity.FullName));
                }
                resolved = true;
            }

            if (resolved)
                return;

            foreach(SimpleTypeReference parent in node.BaseTypes)
            {
                if(_classDefinitionList.Contains(parent.Name))
                {
                    depth++;
                    ResolveClassAbstractProperty(_classDefinitionList[parent.Name] as ClassDefinition, baseTypeRef, entity);
                    depth--;
                }
            }

            if(CheckInheritsInterfaceImplementation(node, entity))
                return;

            if(depth == 0)
            {
                node.Members.Add(CreateAbstractProperty(baseTypeRef, entity));
                AbstractMemberNotImplemented(node, baseTypeRef, entity);
            }
        }

        void ResolveInterfaceMembers(ClassDefinition node,
			TypeReference baseTypeRef,
			IType baseType)
        {
            foreach (IType entity in baseType.GetInterfaces())
            {
                ResolveInterfaceMembers(node, baseTypeRef, entity);
            }

            foreach (IMember entity in baseType.GetMembers())
            {
                ResolveAbstractMember(node, baseTypeRef, entity);
            }
        }

 private static bool IsUnknown(TypeReference typeRef)
 {
     return Unknown.Default == typeRef.Entity;
 }

 //returns true if a stub has been created, false otherwise.
 //TODO: add entity argument to the method to not need return type?
 bool AbstractMemberNotImplemented(ClassDefinition node, TypeReference baseTypeRef, IMember member)
 {
     if (IsValueType(node))
     {
         Error(CompilerErrorFactory.ValueTypeCantHaveAbstractMember(baseTypeRef, node.FullName, GetAbstractMemberSignature(member)));
         return false;
     }
     if (!node.IsAbstract)
     {
         //BEHAVIOR >= 0.7.7:	(see BOO-789 for details)
         //create a stub for this not implemented member
         //it will raise a NotImplementedException if called at runtime
         TypeMember m = CodeBuilder.CreateStub(member);
         CompilerWarning warning = null;
         if (null != m)
         {
             warning = CompilerWarningFactory.AbstractMemberNotImplementedStubCreated(baseTypeRef,
                                 node.FullName, GetAbstractMemberSignature(member));
             node.Members.Add(m);
         }
         else
         {
             warning = CompilerWarningFactory.AbstractMemberNotImplemented(baseTypeRef,
                                 node.FullName, GetAbstractMemberSignature(member));
             _newAbstractClasses.AddUnique(node);
         }
         Warnings.Add(warning);
         return (null != m);
     }
     return false;
 }

        Property CreateAbstractProperty(TypeReference reference, IProperty property)
        {
            Debug.Assert(0 == property.GetParameters().Length);
            Property p = CodeBuilder.CreateProperty(property.Name, property.Type);
            p.Modifiers |= TypeMemberModifiers.Abstract;

            IMethod getter = property.GetGetMethod();
            if (getter != null)
            {
                p.Getter = CodeBuilder.CreateAbstractMethod(reference.LexicalInfo, getter);
            }

            IMethod setter = property.GetSetMethod();
            if (setter != null)
            {
                p.Setter = CodeBuilder.CreateAbstractMethod(reference.LexicalInfo, setter);
            }
            return p;
        }

		private void CheckForCycles(TypeReference baseTypeRef, AbstractInternalType baseType, List<TypeDefinition> visited)
		{
			if (visited.Contains(baseType.TypeDefinition))
			{
				BaseTypeError(CompilerErrorFactory.InheritanceCycle(baseTypeRef, baseType.FullName));
				return;
			}
			
			new BaseTypeResolution(Context, baseType.TypeDefinition, visited);
		}