internal static WebFile FromDbValue(WebFile file, string content, TypeBase type)
        {
            /*if (url == null) return null;
            var u = url.AsUri();
            var file =
                type == TypeBase.WebImage ? WebImage.FromUrl(u) :
                type == TypeBase.WebAudio ? WebAudio.FromUrl(u) :
                type == TypeBase.WebVideo ? WebVideo.FromUrl(u) :
                WebFile.FromUrl(u);
                */
            if (content != null)
            {
                var serializer = new JsonSerializer();

                serializer.AddAwdeeConverters();
                using (var sr = new StringReader(content))
                using (var jr = Utils.CreateJsonReader(sr))
                {
                    serializer.Deserialize(jr, type.NativeType);
                }

            }

            return file;
        }

        public RegisterFrameResource(Frame frame, TypeBase type, Register register)
            : base(frame, type)
        {
            Register = register;

            if (type is PointerType)
            {
                _type = OperandValueType.Dword;
            }
            else
            {
                var typePrim = type as PrimitiveType;
                if (typePrim == null)
                    throw new ArgumentException("Type must be a primitive.", nameof(type));

                switch (typePrim.Type)
                {
                    case Primitive.Int:
                        _type = OperandValueType.Dword;
                        break;
                    case Primitive.Short:
                        _type = OperandValueType.Word;
                        break;
                    case Primitive.Char:
                        _type = OperandValueType.Byte;
                        break;
                    default:
                        throw new NotSupportedException();
                }
            }
        }

        public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
        {
            if (!base.IsAssignableTo(other, depth, checkConst))
                return false;

            return other is BoolType;
        }

 internal SymmetricClosureService(TypeBase source)
 {
     Source = source;
     AllFeatures = source
         .SymmetricFeatureClosure()
         .ToArray();
 }

        public override bool Equals(TypeBase other)
        {
            if (!base.Equals(other))
                return false;

            return other is BoolType;
        }

 int CreateFunctionInstance(TypeBase args, FunctionSyntax syntax, CompoundView compoundView)
 {
     var index = _list.Count;
     var f = new FunctionType(index, syntax, compoundView, args);
     _list.Add(f);
     return index;
 }

        public override bool Equals(TypeBase other)
        {
            if (!base.Equals(other))
                return false;

            return IsConstant == other.IsConstant && other is PointerType;
        }

 internal Value(Func<Category, Result> function, TypeBase source)
     : base(_nextObjectId++)
 {
     Function = function;
     Source = source;
     Tracer.Assert(Source != null);
 }

        public ArrayType(TypeBase innerType, int count, bool constant = false)
            : base(innerType, constant)
        {
            if (count <= 0)
                throw new ArgumentOutOfRangeException(nameof(count));

            Count = count;
        }

        protected TypeModifier(TypeBase innerType, bool constant = false)
            : base(constant)
        {
            if (innerType == null)
                throw new ArgumentNullException(nameof(innerType));

            InnerType = innerType;
        }

 internal Function(ContextBase parent, TypeBase argsType, TypeBase valueType = null)
     : base(parent)
 {
     _order = CodeArgs.NextOrder++;
     ArgsType = argsType;
     ValueType = valueType;
     StopByObjectIds();
 }

 internal Conversion(Func<Category, Result> function, TypeBase source)
     : base(_nextObjectId++)
 {
     Function = function;
     Source = source;
     Tracer.Assert(Source != null);
     StopByObjectIds();
 }

        internal Result Result(Category category, Result leftResult, TypeBase right)
        {
            var rightResult = right
                .Conversion(category.Typed, IndexType)
                .AutomaticDereferencedAlignedResult();

            return Result(category, leftResult + rightResult);
        }

 public static SearchResult Create(IImplementation feature, TypeBase definingItem)
 {
     var searchResult = feature as SearchResult;
     if(searchResult == null)
         return new SearchResult(feature, definingItem);
     var source = searchResult.Source;
     Tracer.Assert(source == definingItem);
     return searchResult;
 }

        public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
        {
            if (!base.IsAssignableTo(other, depth, checkConst))
                return false;

            if (depth > 0 && other is AnyType)
                return true;

            return Equals(other);
        }

        private Type GetClrType(TypeBase t)
        {
            var clrType = m_typeTable.Get(t);
            if (clrType != null)
            {
                return clrType;
            }

            CodeClassType ccType = t as CodeClassType;

            if (ccType != null)
            {
                Type baseClass = typeof(Object);

                if (ccType.BaseType != null)
                {
                    baseClass = GetClrType(ccType.BaseType);
                }

                clrType = m_module.DefineType(t.Name, TypeAttributes.Class | TypeAttributes.BeforeFieldInit, baseClass);

                m_typeTable.Set(t, clrType);
                return clrType;
            }

            ArrayType aType = t as ArrayType;
            if (aType != null)
            {
                var elementType = GetClrType(aType.ElementType);

                clrType = elementType.MakeArrayType();
                m_typeTable.Set(t, clrType);

                return clrType;
            }

            PrimaryType pType = t as PrimaryType;

            switch (pType.Name)
            {
                case "int":
                    clrType = typeof(int);
                    break;
                case "bool":
                    clrType = typeof(bool);
                    break;
                default:
                    Debug.Assert(false, "unknown primary type");
                    break;
            }

            m_typeTable.Set(t, clrType);
            return clrType;

        }

        public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
        {
            if (!base.IsAssignableTo(other, depth, checkConst))
                return false;

            var otherMod = other as TypeModifier;
            if (otherMod == null)
                return false;

            return InnerType.IsAssignableTo(otherMod.InnerType, depth + 1);
        }

        public override bool Equals(TypeBase other)
        {
            if (!base.Equals(other))
                return false;

            var otherMod = other as TypeModifier;
            if (otherMod == null)
                return false;

            return InnerType.Equals(otherMod.InnerType);
        }

        public override bool Equals(TypeBase other)
        {
            if (!base.Equals(other))
                return false;

            var otherArray = other as ArrayType;
            if (otherArray == null)
                return false;

            return IsConstant == other.IsConstant && Count == otherArray.Count;
        }

        public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
        {
            if (!base.IsAssignableTo(other, depth, checkConst))
                return false;

            if (other is PointerType)
                return true;

            var otherArray = other as ArrayType;
            return Count >= otherArray?.Count;
        }