Example #1
0
        public static void AddMembers(this IMemberContainer parent,
                                      MemberDeclarationSyntax s,
                                      SortedSet <FieldInfo> fields        = null,
                                      SortedSet <PropertyInfo> properties = null,
                                      SortedSet <IndexerInfo> indexers    = null,
                                      SortedSet <MemberInfoBase> methods  = null)
        {
            // ugly but works
            switch (s)
            {
            case FieldDeclarationSyntax decl:
                fields?.Add(new FieldInfo(decl, parent)); break;

            case PropertyDeclarationSyntax decl:
                properties?.Add(new PropertyInfo(decl, parent)); break;

            case IndexerDeclarationSyntax decl:
                indexers?.Add(new IndexerInfo(decl, parent)); break;

            case MethodDeclarationSyntax decl:
                methods?.Add(new MethodInfo(decl, parent)); break;

            case ConstructorDeclarationSyntax decl:
                methods?.Add(new ConstructorInfo(decl, parent)); break;

            case OperatorDeclarationSyntax decl:
                methods?.Add(new OperatorInfo(decl, parent)); break;
            }
        }
Example #2
0
 private void AddMembers(MemberTypes mt, IMemberContainer container)
 {
     AddMembers(mt, BindingFlags.Static | BindingFlags.Public, container);
     AddMembers(mt, BindingFlags.Static | BindingFlags.NonPublic, container);
     AddMembers(mt, BindingFlags.Instance | BindingFlags.Public, container);
     AddMembers(mt, BindingFlags.Instance | BindingFlags.NonPublic, container);
 }
Example #3
0
        /// <summary>Create a new MemberCache for the given IMemberContainer `container'.</summary>
        public MemberCache(IMemberContainer container)
        {
            Container = container;

            // If we have a base class (we have a base class unless we're
            // TypeManager.object_type), we deep-copy its MemberCache here.
            if (Container.BaseCache != null)
            {
                MemberHash = SetupCache(Container.BaseCache);
            }
            else
            {
                MemberHash = new Hashtable();
            }

            // If this is neither a dynamic type nor an interface, create a special
            // method cache with all declared and inherited methods.
            var type = container.Type;

            if (!(type is TypeBuilder) && !type.IsInterface &&
                !TypeManager.IsGenericType(type) && !TypeManager.IsGenericParameter(type) &&
                (Container.BaseCache == null || Container.BaseCache.MethodHash != null))
            {
                MethodHash = new Hashtable();
                AddMethods(type);
            }

            // Add all members from the current class.
            AddMembers(Container);
        }
Example #4
0
        public CPythonType(IMemberContainer parent, ITypeDatabaseReader typeDb, string typeName, Dictionary<string, object> typeTable, BuiltinTypeId typeId) {
            Debug.Assert(parent is CPythonType || parent is CPythonModule);
            Debug.Assert(!typeId.IsVirtualId());

            _typeName = typeName;
            _typeId = typeId;
            _module = GetDeclaringModule(parent);

            object value;
            if (typeTable.TryGetValue("is_hidden", out value)) {
                _includeInModule = !Convert.ToBoolean(value);
            } else {
                _includeInModule = true;
            }

            if (typeTable.TryGetValue("doc", out value)) {
                _doc = value as string;
            }

            if (typeTable.TryGetValue("builtin", out value)) {
                _isBuiltin = Convert.ToBoolean(value);
            } else {
                _isBuiltin = true;
            }

            if (typeTable.TryGetValue("bases", out value)) {
                var basesList = (List<object>)value;
                if (basesList != null) {
                    _bases = new List<IPythonType>();
                    foreach (var baseType in basesList) {
                        typeDb.LookupType(baseType, StoreBase);
                    }
                }
            }

            if (typeTable.TryGetValue("mro", out value)) {
                var mroList = (List<object>)value;
                if (mroList != null && mroList.Count >= 1) {
                    _mro = new IPythonType[mroList.Count];
                    // Many scraped types have invalid MRO entries because they
                    // report their own module/name incorrectly. Since the first
                    // item in the MRO is always self, we set it now. If the MRO
                    // has a resolvable entry it will replace this one.
                    _mro[0] = this;
                    for (int i = 0; i < mroList.Count; ++i) {
                        var capturedI = i;
                        typeDb.LookupType(mroList[i], t => _mro[capturedI] = t);
                    }
                }
            }

            if (typeTable.TryGetValue("members", out value)) {
                var membersTable = (Dictionary<string, object>)value;
                if (membersTable != null) {
                    LoadMembers(typeDb, membersTable);
                }
            }

            _hasLocation = PythonTypeDatabase.TryGetLocation(typeTable, ref _line, ref _column);
        }
Example #5
0
        public IndexerInfo(IndexerDeclarationSyntax decl, IMemberContainer parent)
        {
            var paramList = decl.ParameterList.Parameters
                            .Select(p => p.Type.ToString());

            if (decl.HasLeadingTrivia)
            {
                Documentation = GetDocumentation(decl.GetLeadingTrivia());
            }

            Name        = decl.Type.ToString() + $"[{string.Join(", ", paramList)}]";
            _parameters = Parse(decl.ParameterList);
            Parent      = parent;
            _modifiers  = decl.Modifiers
                          .ParseModifiers()
                          .WithDefaultVisibility(Parent is InterfaceInfo ?
                                                 Modifier.Public : Modifier.Private);

            ReturnType = decl.Type.ToString();
            Signature  = $"{ReturnType} this[{ParamSyntax()}]";

            var accessors = decl.AccessorList?.Accessors
                            .Select(a => new AccessorInfo(a, this));

            if (accessors != null)
            {
                Setter = accessors.FirstOrDefault(a => a.IsSetter);
                Getter = accessors.FirstOrDefault(a => a.IsGetter);
            }
            else if (decl.ExpressionBody != null)
            {
                Getter = new AccessorInfo(this);
            }
        }
Example #6
0
        public CJFunction(ITypeDatabaseReader typeDb, string name, Dictionary<string, object> functionTable, IMemberContainer declaringType, bool isMethod = false)
        {
            _name = name;

            object doc;
            if (functionTable.TryGetValue("doc", out doc)) {
                _doc = doc as string;
            }

            object value;
            if (functionTable.TryGetValue("builtin", out value)) {
                _isBuiltin = Convert.ToBoolean(value);
            } else {
                _isBuiltin = true;
            }

            if (functionTable.TryGetValue("static", out value)) {
                _isStatic = Convert.ToBoolean(value);
            } else {
                _isStatic = true;
            }

            _hasLocation = JTypeDatabase.TryGetLocation(functionTable, ref _line, ref _column);

            _declaringModule = CJModule.GetDeclaringModuleFromContainer(declaringType);
            object overloads;
            functionTable.TryGetValue("overloads", out overloads);
            _overloads = LoadOverloads(typeDb, overloads, isMethod);
            _declaringType = declaringType as IJType;
        }
Example #7
0
        public IEnumerable <IReferenceable> GetDefinitions(string name, IMemberContainer innerContainer, IModuleContext context)
        {
            var res = new List <IReferenceable>();

            ReferenceDict references;

            lock (_references) {
                _references.TryGetValue(name, out references);
            }

            if (references != null)
            {
                lock (references) {
                    res.AddRange(references.Values);
                }
            }

            var member = innerContainer.GetMember(context, name) as ILocatedMember;

            if (member != null)
            {
                res.AddRange(member.Locations.MaybeEnumerate().Select(loc => new DefinitionList(loc)));
            }

            return(res);
        }
Example #8
0
        public MethodInfo(MethodDeclarationSyntax decl, IMemberContainer parent)
        {
            var paramTypes = decl.ParameterList.Parameters
                             .Select(p => p.Type.ToString());
            var typeParams = Format(decl.TypeParameterList);

            Name = $"{decl.Identifier.Text}{typeParams}" +
                   $"({string.Join(", ", paramTypes)})";
            _parameters = Parse(decl.ParameterList);
            Parent      = parent;
            _modifiers  = decl.Modifiers
                          .ParseModifiers()
                          .WithDefaultVisibility(Parent is InterfaceInfo ?
                                                 Modifier.Public : Modifier.Private);

            Signature = $"{decl.ReturnType} {decl.Identifier.Text}" +
                        $"{typeParams}({ParamSyntax()})";

            if (decl.HasLeadingTrivia)
            {
                Documentation = GetDocumentation(decl.GetLeadingTrivia());
            }

            ReturnType = decl.ReturnType.ToString();
        }
Example #9
0
    public override float Value(IMemberContainer member)
    {
        Dictionary <TileNode, RenderedTileInfo> nodes = ((MemberTilePCG)member).renderedTiles;
        Vector3 maxLoc = Vector3.zero;

        foreach (KeyValuePair <TileNode, RenderedTileInfo> node in nodes)
        {
            if (node.Key.type == TileGraphPCG.tileMap["1Door"])
            {
                if (node.Value.location.magnitude > maxLoc.magnitude)
                {
                    maxLoc = node.Value.location;
                }
            }
        }
        float totalDist = 0;

        foreach (KeyValuePair <TileNode, RenderedTileInfo> node in nodes)
        {
            float dist = Vector3.Dot(node.Value.location, maxLoc.normalized);
            if (dist < 0)
            {
                totalDist += node.Value.location.magnitude;
            }
            else if (dist > maxLoc.magnitude)
            {
                totalDist += (node.Value.location - maxLoc).magnitude;
            }
            else
            {
                totalDist += (node.Value.location - dist * maxLoc.normalized).magnitude;
            }
        }
        return(totalDist / 10);
    }
Example #10
0
        public MemberCache(IMemberContainer container, Type baseClass, Type[] ifaces)
        {
            Container = container;

            // If we have a base class (we have a base class unless we're
            // TypeManager.object_type), we deep-copy its MemberCache here.
            if (Container.BaseCache != null)
            {
                MemberHash = SetupCache(Container.BaseCache);
            }
            else
            {
                MemberHash = new Hashtable();
            }

            if (baseClass != null)
            {
                AddCacheContents(TypeHandle.GetMemberCache(baseClass));
            }
            if (ifaces != null)
            {
                foreach (var itype in ifaces)
                {
                    var cache = TypeHandle.GetMemberCache(itype);
                    if (cache != null)
                    {
                        AddCacheContents(cache);
                    }
                }
            }
        }
Example #11
0
        internal IDictionary <string, IAnalysisSet> GetAllMembers(IMemberContainer container, IModuleContext moduleContext)
        {
            var names  = container.GetMemberNames(moduleContext);
            var result = new Dictionary <string, IAnalysisSet>();

            foreach (var name in names)
            {
                result[name] = GetAnalysisValueFromObjects(container.GetMember(moduleContext, name));
            }
            var children = (container as IModule)?.GetChildrenPackages(moduleContext);

            if (children?.Any() ?? false)
            {
                foreach (var child in children)
                {
                    IAnalysisSet existing;
                    if (result.TryGetValue(child.Key, out existing))
                    {
                        result[child.Key] = existing.Add(child.Value);
                    }
                    else
                    {
                        result[child.Key] = child.Value;
                    }
                }
            }

            return(result);
        }
Example #12
0
    private static void CheckAddFinalCandidate(IMemberContainer m, List <float> vals)
    {
        List <IMemberContainer> membersToRemove = new List <IMemberContainer>();

        foreach (KeyValuePair <IMemberContainer, List <float> > kvp in finalCandidates)
        {
            switch (CompareMembers(m, vals, kvp.Key, kvp.Value))
            {
            case MemberComparison.DOMINATED:
                return;

            case MemberComparison.DOMINATES:
                membersToRemove.Add(kvp.Key);
                break;

            case MemberComparison.NEUTRAL:
                break;
            }
        }
        foreach (IMemberContainer rm in membersToRemove)
        {
            finalCandidates.Remove(rm);
        }
        finalCandidates.Add(m.CopyGenotype(), vals);
    }
 public EventPropertyNodeWithSymbols(
     EventDeclarationSyntax declaration,
     IMemberContainer container,
     SemanticModel semanticModel)
     : base(declaration, container)
 {
     this.semanticModel = semanticModel;
 }
Example #14
0
 public OperatorOverloadNodeWithSymbols(
     OperatorDeclarationSyntax declaration,
     IMemberContainer container,
     SemanticModel semanticModel)
     : base(declaration, container)
 {
     this.semanticModel = semanticModel;
 }
Example #15
0
 public ConstructorNodeWithSymbols(
     ConstructorDeclarationSyntax declaration,
     IMemberContainer container,
     SemanticModel semanticModel)
     : base(declaration, container)
 {
     this.semanticModel = semanticModel;
 }
Example #16
0
 public CPythonMethodDescriptor(ITypeDatabaseReader typeDb, string name, Dictionary<string, object> valueDict, IMemberContainer declaringType) {
     _name = name;
     _func = new CPythonFunction(typeDb, name, valueDict, declaringType, isMethod: true);
     object value;
     if (valueDict.TryGetValue("bound", out value)) {
         _isBound = (value as bool?) ?? false;
     }
 }
 public FieldNodeWithSymbols(
     FieldDeclarationSyntax declaration,
     IMemberContainer container,
     SemanticModel semanticModel)
     : base(declaration, container)
 {
     this.semanticModel = semanticModel;
 }
Example #18
0
 internal CPythonFunction(string name, string doc, bool isBuiltin, bool isStatic, IMemberContainer declaringType) {
     _name = name;
     _doc = doc;
     _isBuiltin = isBuiltin;
     _isStatic = isStatic;
     _declaringModule = CPythonModule.GetDeclaringModuleFromContainer(declaringType);
     _declaringType = declaringType as IPythonType;
     _overloads = new List<IPythonFunctionOverload>();
 }
Example #19
0
 public CacheEntry(
     IMemberContainer container,
     MemberInfo member,
     MemberTypes mt,
     BindingFlags bf)
 {
     Container = container;
     Member    = member;
     EntryType = GetEntryType(mt, bf);
 }
Example #20
0
        public CJType(IMemberContainer parent, ITypeDatabaseReader typeDb, string typeName, Dictionary<string, object> typeTable, BuiltinTypeId typeId)
        {
            Debug.Assert(parent is CJType || parent is CJModule);

            _typeName = typeName;
            _typeId = typeId;
            _module = GetDeclaringModule(parent);

            object value;
            if (typeTable.TryGetValue("is_hidden", out value)) {
                _includeInModule = !Convert.ToBoolean(value);
            } else {
                _includeInModule = true;
            }

            if (typeTable.TryGetValue("doc", out value)) {
                _doc = value as string;
            }

            if (typeTable.TryGetValue("builtin", out value)) {
                _isBuiltin = Convert.ToBoolean(value);
            } else {
                _isBuiltin = true;
            }

            if (typeTable.TryGetValue("bases", out value)) {
                var basesList = value as List<object>;
                if (basesList != null) {
                    _bases = new List<IJType>();
                    foreach (var baseType in basesList) {
                        typeDb.LookupType(baseType, StoreBase);
                    }
                }
            }

            if (typeTable.TryGetValue("mro", out value)) {
                var mroList = value as List<object>;
                if (mroList != null) {
                    _mro = new List<CJType>();
                    foreach (var mroType in mroList) {
                        typeDb.LookupType(mroType, StoreMro);
                    }
                }
            }

            object membersData;
            if (typeTable.TryGetValue("members", out membersData)) {
                var membersTable = membersData as Dictionary<string, object>;
                if (membersTable != null) {
                    LoadMembers(typeDb, membersTable);
                }
            }

            _hasLocation = JTypeDatabase.TryGetLocation(typeTable, ref _line, ref _column);
        }
Example #21
0
    public override float Value(IMemberContainer member)
    {
        List <RenderedTileInfo> renderedTiles = new List <RenderedTileInfo>(((MemberTilePCG)member).renderedTiles.Values);
        float distance = 0;

        foreach (RenderedTileInfo rti in renderedTiles)
        {
            distance += rti.location.magnitude;
        }
        return(distance / renderedTiles.Count);
    }
Example #22
0
 public MemberCache(Type baseType, IMemberContainer container)
 {
     Container = container;
     if (baseType == null)
     {
         MemberHash = new Hashtable();
     }
     else
     {
         MemberHash = SetupCache(TypeHandle.GetMemberCache(baseType));
     }
 }
Example #23
0
        internal IDictionary <string, ISet <Namespace> > GetAllMembers(IMemberContainer container, IModuleContext moduleContext)
        {
            var names  = container.GetMemberNames(moduleContext);
            var result = new Dictionary <string, ISet <Namespace> >();

            foreach (var name in names)
            {
                result[name] = GetNamespaceFromObjects(container.GetMember(moduleContext, name));
            }

            return(result);
        }
Example #24
0
        public CPythonMultipleMembers(IMemberContainer container, ITypeDatabaseReader typeDb, string name, IEnumerable<object> members) {
            _members = new List<IMember>();
            _memberNames = members.OfType<Dictionary<string, object>>().ToList<object>();
            _memberObjects = new IMember[_memberNames.Count];

            // Copy the count because _memberNames may be cleared before the
            // loop finishes executing.
            int count = _memberNames.Count;
            for (int i = 0; i < count; ++i) {
                var capturedI = i;
                typeDb.ReadMember(name, (Dictionary<string, object>)_memberNames[i], (_, member) => AddType(capturedI, member), container);
            }
        }
Example #25
0
 private IMember[] GetMultipleMembers(string memberName, IMemberContainer container, object[] memsArray)
 {
     IMember[] finalMembers = new IMember[memsArray.Length];
     for (int i = 0; i < finalMembers.Length; i++)
     {
         var curMember = memsArray[i] as Dictionary <string, object>;
         var tmp       = i; // close over the current value of i, not the last one...
         if (curMember != null)
         {
             ReadMember(memberName, curMember, (name, newMemberValue) => finalMembers[tmp] = newMemberValue, container);
         }
     }
     return(finalMembers);
 }
Example #26
0
    public override float Value(IMemberContainer member)
    {
        List <RenderedTileInfo> renderedNodes = new List <RenderedTileInfo>(((MemberTilePCG)member).renderedTiles.Values);
        float maxDistance = 0;

        foreach (RenderedTileInfo n in renderedNodes)
        {
            if (n.location.magnitude > maxDistance)
            {
                maxDistance = n.location.magnitude;
            }
        }
        return(maxDistance);
    }
Example #27
0
 private TypeHandle(Type type)
 {
     _type     = type;
     _fullName = type.FullName ?? type.Name;
     if (type.BaseType != null)
     {
         _baseCache     = GetMemberCache(type.BaseType);
         _baseContainer = _baseCache.Container;
     }
     else if (type.IsInterface)
     {
         _baseCache = TypeManager.LookupBaseInterfacesCache(type);
     }
     _isInterface = type.IsInterface || TypeManager.IsGenericParameter(type);
     _memberCache = new MemberCache(this);
 }
Example #28
0
        public CJProperty(ITypeDatabaseReader typeDb, Dictionary<string, object> valueDict, IMemberContainer container)
        {
            _declaringModule = CJModule.GetDeclaringModuleFromContainer(container);

            object value;
            if (valueDict.TryGetValue("doc", out value)) {
                _doc = value as string;
            }

            object type;
            valueDict.TryGetValue("type", out type);

            _hasLocation = JTypeDatabase.TryGetLocation(valueDict, ref _line, ref _column);

            typeDb.LookupType(type, (typeValue, fromInstanceDb) => _type = typeValue);
        }
        public CPythonMultipleMembers(IMemberContainer container, ITypeDatabaseReader typeDb, string name, IEnumerable <object> members)
        {
            _members       = new List <IMember>();
            _memberNames   = members.OfType <Dictionary <string, object> >().ToList <object>();
            _memberObjects = new IMember[_memberNames.Count];

            // Copy the count because _memberNames may be cleared before the
            // loop finishes executing.
            int count = _memberNames.Count;

            for (int i = 0; i < count; ++i)
            {
                var capturedI = i;
                typeDb.ReadMember(name, (Dictionary <string, object>)_memberNames[i], (_, member) => AddType(capturedI, member), container);
            }
        }
Example #30
0
    public override float Value(IMemberContainer member)
    {
        List <TileNode> nodes = ((MemberTilePCG)member).graph.nodes;
        float           val   = 0;

        foreach (TileNode node in nodes)
        {
            foreach (TileNode c in node.connectedNodes)
            {
                if (node.type != c.type)
                {
                    val += 1;
                }
            }
        }
        return(val);
    }
Example #31
0
    public override float Value(IMemberContainer member)
    {
        Dictionary <TileNode, RenderedTileInfo> nodes = ((MemberTilePCG)member).renderedTiles;
        Vector3 maxLoc = Vector3.zero;

        foreach (KeyValuePair <TileNode, RenderedTileInfo> node in nodes)
        {
            if (node.Key.type == TileGraphPCG.tileMap["1Door"])
            {
                if (node.Value.location.magnitude > maxLoc.magnitude)
                {
                    maxLoc = node.Value.location;
                }
            }
        }
        return(maxLoc.magnitude);
    }
Example #32
0
        public CPythonProperty(ITypeDatabaseReader typeDb, Dictionary<string, object> valueDict, IMemberContainer container) {
            _declaringModule = CPythonModule.GetDeclaringModuleFromContainer(container);

            object value;
            if (valueDict.TryGetValue("doc", out value)) {
                _doc = value as string;
            }

            object type;
            if (!valueDict.TryGetValue("type", out type) || type == null) {
                type = new[] { null, "object" };
            }

            _hasLocation = PythonTypeDatabase.TryGetLocation(valueDict, ref _line, ref _column);

            typeDb.LookupType(type, typeValue => _type = typeValue);
        }
Example #33
0
        public CPythonType(IMemberContainer parent, TypeDatabase typeDb, string typeName, Dictionary <string, object> typeTable, BuiltinTypeId typeId)
        {
            Debug.Assert(parent is CPythonType || parent is CPythonModule);

            _typeName = typeName;
            _typeId   = typeId;
            _module   = GetDeclaringModule(parent);

            object value;

            if (typeTable.TryGetValue("is_hidden", out value))
            {
                _includeInModule = !Convert.ToBoolean(value);
            }
            else
            {
                _includeInModule = true;
            }

            if (typeTable.TryGetValue("doc", out value))
            {
                _doc = value as string;
            }

            if (typeTable.TryGetValue("builtin", out value))
            {
                _isBuiltin = Convert.ToBoolean(value);
            }
            else
            {
                _isBuiltin = true;
            }

            object membersData;

            if (typeTable.TryGetValue("members", out membersData))
            {
                var membersTable = membersData as Dictionary <string, object>;
                if (membersTable != null)
                {
                    LoadMembers(typeDb, membersTable);
                }
            }
        }
Example #34
0
        public MemberCache(Type[] ifaces)
        {
            //
            // The members of this cache all belong to other caches.
            // So, 'Container' will not be used.
            //
            Container = null;

            MemberHash = new Hashtable();
            if (ifaces == null)
            {
                return;
            }

            foreach (var itype in ifaces)
            {
                AddCacheContents(TypeHandle.GetMemberCache(itype));
            }
        }
Example #35
0
    private static MemberComparison CompareMembers(IMemberContainer m1, List <float> v1, IMemberContainer m2, List <float> v2)
    {
        bool isGreaterInOneDimension = false;
        bool isLessInOneDimension    = false;

        for (int i = 0; i < v1.Count; i++)
        {
            if (variables[i].IsPositive())
            {
                if (v1[i] > v2[i])
                {
                    isGreaterInOneDimension = true;
                }
                else
                {
                    isLessInOneDimension = true;
                }
            }
            else
            {
                if (v1[i] < v2[i])
                {
                    isGreaterInOneDimension = true;
                }
                else
                {
                    isLessInOneDimension = true;
                }
            }
        }
        // The new solution is dominated.
        if (!isGreaterInOneDimension)
        {
            return(MemberComparison.DOMINATED);
        }
        // This existing solution is dominated by the new solution.
        if (!isLessInOneDimension)
        {
            return(MemberComparison.DOMINATES);
        }
        return(MemberComparison.NEUTRAL);
    }
Example #36
0
        /// <summary>
        ///   Add all members from class `container' with the requested MemberTypes and
        ///   BindingFlags to the cache.  This method is called multiple times with different
        ///   MemberTypes and BindingFlags.
        /// </summary>
        private void AddMembers(MemberTypes mt, BindingFlags bf, IMemberContainer container)
        {
            var members = container.GetMembers(mt, bf);

            foreach (var member in members)
            {
                var name = member.Name;

                AddMember(mt, bf, container, name, member);

                if (member is MethodInfo)
                {
                    var gname = TypeManager.GetMethodName((MethodInfo)member);
                    if (gname != name)
                    {
                        AddMember(mt, bf, container, gname, member);
                    }
                }
            }
        }
Example #37
0
        public PropertyInfo(PropertyDeclarationSyntax decl, IMemberContainer parent)
        {
            Name = decl.Identifier.Text;
            if (decl.HasLeadingTrivia)
            {
                Documentation = GetDocumentation(decl.GetLeadingTrivia());
            }
            Parent     = parent;
            _modifiers = decl.Modifiers
                         .ParseModifiers()
                         .WithDefaultVisibility(Parent is InterfaceInfo ?
                                                Modifier.Public : Modifier.Private);

            ReturnType = decl.Type.ToString();

            var accessors = decl.AccessorList?.Accessors
                            .Select(a => new AccessorInfo(a, this));

            if (accessors != null)
            {
                Setter = accessors.FirstOrDefault(a => a.IsSetter);
                Getter = accessors.FirstOrDefault(a => a.IsGetter);
            }
            else if (decl.ExpressionBody != null)
            {
                Getter = new AccessorInfo(this);
            }

            _parameters = new List <ParameterInfo>();
            Signature   = $"{ReturnType} {Name} " + "{";
            if (HasGetter)
            {
                Signature += Getter.ToString();
            }
            if (HasSetter)
            {
                Signature += Setter.ToString();
            }
            Signature += " }";
        }
Example #38
0
 /// <summary>Add all members from class `container' to the cache.</summary>
 private void AddMembers(IMemberContainer container)
 {
     // We need to call AddMembers() with a single member type at a time
     // to get the member type part of CacheEntry.EntryType right.
     if (!container.IsInterface)
     {
         AddMembers(MemberTypes.Constructor, container);
         AddMembers(MemberTypes.Field, container);
     }
     AddMembers(MemberTypes.Method, container);
     AddMembers(MemberTypes.Property, container);
     AddMembers(MemberTypes.Event, container);
     // Nested types are returned by both Static and Instance searches.
     AddMembers(
         MemberTypes.NestedType,
         BindingFlags.Static | BindingFlags.Public,
         container);
     AddMembers(
         MemberTypes.NestedType,
         BindingFlags.Static | BindingFlags.NonPublic,
         container);
 }
Example #39
0
        public void ReadMember(string memberName, Dictionary<string, object> memberValue, Action<string, IMember> assign, IMemberContainer container, JTypeDatabase instanceDb = null)
        {
            object memberKind;
            object value;
            Dictionary<string, object> valueDict;

            if (memberValue.TryGetValue("value", out value) &&
                (valueDict = (value as Dictionary<string, object>)) != null &&
                memberValue.TryGetValue("kind", out memberKind) && memberKind is string) {
                switch ((string)memberKind) {
                    case "function":
                        if (CheckVersion(valueDict)) {
                            assign(memberName, new CJFunction(this, memberName, valueDict, container));
                        }
                        break;
                    case "func_ref":
                        string funcName;
                        if (valueDict.TryGetValue("func_name", out value) && (funcName = value as string) != null) {
                            var names = funcName.Split('.');
                            IJModule mod;
                            if (_modules.TryGetValue(names[0], out mod) ||
                                (instanceDb != null && instanceDb._modules.TryGetValue(names[0], out mod))) {
                                if (names.Length == 2) {
                                    var mem = mod.GetMember(null, names[1]);
                                    if (mem == null) {
                                        AddFixup(() => {
                                            var tmp = mod.GetMember(null, names[1]);
                                            if (tmp != null) {
                                                assign(memberName, tmp);
                                            }
                                        });
                                    } else {
                                        assign(memberName, mem);
                                    }
                                } else {
                                    LookupType(new object[] { names[0], names[1] }, (type, fromInstanceDb) => {
                                        var mem = type.GetMember(null, names[2]);
                                        if (mem != null) {
                                            assign(memberName, mem);
                                        }
                                    }, instanceDb);
                                }
                            }
                        }
                        break;
                    case "method":
                        if (CheckVersion(valueDict)) {
                            assign(memberName, new CJMethodDescriptor(this, memberName, valueDict, container));
                        }
                        break;
                    case "property":
                        if (CheckVersion(valueDict)) {
                            assign(memberName, new CJProperty(this, valueDict, container));
                        }
                        break;
                    case "data":
                        object typeInfo;
                        if (valueDict.TryGetValue("type", out typeInfo) && CheckVersion(valueDict)) {
                            LookupType(
                                typeInfo,
                                (dataType, fromInstanceDb) => {
                                    assign(memberName, fromInstanceDb ? instanceDb.GetConstant(dataType) : GetConstant(dataType));
                                },
                                instanceDb
                            );
                        }
                        break;
                    case "type":
                        if (CheckVersion(valueDict)) {
                            assign(memberName, MakeType(memberName, valueDict, container));
                        }
                        break;
                    case "multiple":
                        object members;
                        object[] memsArray;
                        if (valueDict.TryGetValue("members", out members) && (memsArray = members as object[]) != null) {
                            IMember[] finalMembers = GetMultipleMembers(memberName, container, memsArray, instanceDb);
                            assign(memberName, new CJMultipleMembers(finalMembers));
                        }
                        break;
                    case "typeref":
                        object typeName;
                        if (valueDict.TryGetValue("type_name", out typeName)) {
                            LookupType(typeName, (dataType, fromInstanceDb) => {
                                assign(memberName, dataType);
                            }, instanceDb);
                        }
                        break;
                    case "moduleref":
                        object modName;
                        if (!valueDict.TryGetValue("module_name", out modName) || !(modName is string)) {
                            throw new InvalidOperationException("Failed to find module name: " + modName);
                        }

                        assign(memberName, GetModule((string)modName, instanceDb));
                        break;
                }
            }
        }
Example #40
0
        public void ReadMember(
            string memberName,
            Dictionary<string, object> memberValue,
            Action<string, IMember> assign,
            IMemberContainer container
        ) {
            object memberKind;
            object value;
            Dictionary<string, object> valueDict;
            List<object> valueList;
            object[] valueArray;

            if (memberValue.TryGetValue("value", out value) &&
                memberValue.TryGetValue("kind", out memberKind) && memberKind is string) {
                if ((valueDict = (value as Dictionary<string, object>)) != null) {
                    switch ((string)memberKind) {
                        case "function":
                            if (CheckVersion(memberValue)) {
                                assign(memberName, new CPythonFunction(this, memberName, valueDict, container));
                            }
                            break;
                        case "funcref":
                            string funcName;
                            if (valueDict.TryGetValue("func_name", out value) && (funcName = value as string) != null) {
                                ResolveMemberRef(funcName.Split('.'), memberName, assign);
                            }
                            break;
                        case "method":
                            if (CheckVersion(memberValue)) {
                                assign(memberName, new CPythonMethodDescriptor(this, memberName, valueDict, container));
                            }
                            break;
                        case "property":
                            if (CheckVersion(memberValue)) {
                                assign(memberName, new CPythonProperty(this, valueDict, container));
                            }
                            break;
                        case "data":
                            object typeInfo;
                            if (valueDict.TryGetValue("type", out typeInfo) && CheckVersion(memberValue)) {
                                LookupType(
                                    typeInfo,
                                    dataType => {
                                        if (!(dataType is IPythonSequenceType)) {
                                            assign(memberName, GetConstant(dataType));
                                        } else {
                                            assign(memberName, dataType);
                                        }
                                    }
                                );
                            }
                            break;
                        case "type":
                            if (CheckVersion(memberValue)) {
                                assign(memberName, MakeType(memberName, valueDict, container));
                            }
                            break;
                        case "multiple":
                            object members;
                            object[] memsArray;
                            if (valueDict.TryGetValue("members", out members) && (memsArray = members as object[]) != null) {
                                assign(memberName, new CPythonMultipleMembers(container, this, memberName, memsArray));
                            }
                            break;
                        default:
                            Debug.Fail("Unexpected member kind: " + (string)memberKind);
                            break;
                    }
                } else if ((valueList = value as List<object>) != null) {
                    switch ((string)memberKind) {
                        case "typeref":
                            if (CheckVersion(memberValue)) {
                                LookupType(valueList, dataType => assign(memberName, dataType));
                            }
                            break;
                        default:
                            Debug.Fail("Unexpected member kind: " + (string)memberKind);
                            break;
                    }
                } else if ((valueArray = value as object[]) != null) {
                    switch ((string)memberKind) {
                        case "moduleref":
                            string modName;
                            if (valueArray.Length >= 1 && !string.IsNullOrEmpty(modName = valueArray[0] as string)) {
                                var module = GetModule(modName);
                                if (module == null) {
                                    List<Action<IMember>> fixups;
                                    if (!_moduleFixups.TryGetValue(modName, out fixups)) {
                                        _moduleFixups[modName] = fixups = new List<Action<IMember>>();
                                    }
                                    fixups.Add(m => assign(memberName, m));
                                } else {
                                    assign(memberName, module);
                                }
                            }
                            break;
                        default:
                            Debug.Fail("Unexpected member kind: " + (string)memberKind);
                            break;
                    }
                }
            }
        }
Example #41
0
        private CPythonType MakeType(string typeName, Dictionary<string, object> valueDict, IMemberContainer container) {
            BuiltinTypeId typeId = BuiltinTypeId.Unknown;
            if (container is IBuiltinPythonModule) {
                typeId = GetBuiltinTypeId(typeName);
            }

            return new CPythonType(container, this, typeName, valueDict, typeId);
        }
Example #42
0
			public CacheEntry (IMemberContainer container, MemberInfo member,
					   MemberTypes mt, BindingFlags bf)
			{
				this.Container = container;
				this.Member = member;
				this.EntryType = GetEntryType (mt, bf);
			}
Example #43
0
 private IMember[] GetMultipleMembers(string memberName, IMemberContainer container, object[] memsArray, JTypeDatabase instanceDb = null)
 {
     IMember[] finalMembers = new IMember[memsArray.Length];
     for (int i = 0; i < finalMembers.Length; i++) {
         var curMember = memsArray[i] as Dictionary<string, object>;
         var tmp = i;    // close over the current value of i, not the last one...
         if (curMember != null) {
             ReadMember(memberName, curMember, (name, newMemberValue) => finalMembers[tmp] = newMemberValue, container, instanceDb);
         }
     }
     return finalMembers;
 }
Example #44
0
		void AddMember (MemberTypes mt, BindingFlags bf, IMemberContainer container,
				string name, MemberInfo member)
		{
			// We use a name-based hash table of ArrayList's.
			ArrayList list = (ArrayList) member_hash [name];
			if (list == null) {
				list = new ArrayList (1);
				member_hash.Add (name, list);
			}

			// When this method is called for the current class, the list will
			// already contain all inherited members from our base classes.
			// We cannot add new members in front of the list since this'd be an
			// expensive operation, that's why the list is sorted in reverse order
			// (ie. members from the current class are coming last).
			list.Add (new CacheEntry (container, member, mt, bf));
		}
Example #45
0
		/// <summary>
		///   Add all members from class `container' with the requested MemberTypes and
		///   BindingFlags to the cache.  This method is called multiple times with different
		///   MemberTypes and BindingFlags.
		/// </summary>
		void AddMembers (MemberTypes mt, BindingFlags bf, IMemberContainer container)
		{
			MemberList members = container.GetMembers (mt, bf);

			foreach (MemberInfo member in members) {
				string name = member.Name;

				AddMember (mt, bf, container, name, member);

				if (member is MethodInfo) {
					string gname = TypeManager.GetMethodName ((MethodInfo) member);
					if (gname != name)
						AddMember (mt, bf, container, gname, member);
				}
			}
		}
Example #46
0
 internal static CJModule GetDeclaringModuleFromContainer(IMemberContainer declaringType)
 {
     return (declaringType as CJModule) ?? (CJModule)((CJType)declaringType).DeclaringModule;
 }
Example #47
0
 private CJModule GetDeclaringModule(IMemberContainer parent)
 {
     return  parent as CJModule ?? (CJModule)((CJType)parent).DeclaringModule;
 }
Example #48
0
		/// <summary>
		///   Populates our TypeBuilder with fields and methods
		/// </summary>
		public override bool DefineMembers (TypeContainer parent)
		{
			MemberInfo [] defined_names = null;

			if (interface_order != null){
				foreach (Interface iface in interface_order)
					if ((iface.ModFlags & Modifiers.NEW) == 0)
						iface.DefineMembers (this);
					else
						Error_KeywordNotAllowed (iface.Location);
			}

			if (RootContext.WarningLevel > 1){
				Type ptype;

				//
				// This code throws an exception in the comparer
				// I guess the string is not an object?
				//
				ptype = TypeBuilder.BaseType;
				if (ptype != null){
					defined_names = (MemberInfo []) FindMembers (
						ptype, MemberTypes.All & ~MemberTypes.Constructor,
						BindingFlags.Public | BindingFlags.Instance |
						BindingFlags.Static, null, null);

					Array.Sort (defined_names, mif_compare);
				}
			}
			
			if (constants != null)
				DefineMembers (constants, defined_names);

			if (fields != null)
				DefineMembers (fields, defined_names);

			if (this is Class){
				if (instance_constructors == null){
					if (default_constructor == null)
						DefineDefaultConstructor (false);
				}

				if (initialized_static_fields != null &&
				    default_static_constructor == null)
					DefineDefaultConstructor (true);
			}

			if (this is Struct){
				//
				// Structs can not have initialized instance
				// fields
				//
				if (initialized_static_fields != null &&
				    default_static_constructor == null)
					DefineDefaultConstructor (true);

				if (initialized_fields != null)
					ReportStructInitializedInstanceError ();
			}

			Pending = PendingImplementation.GetPendingImplementations (this);
			
			//
			// Constructors are not in the defined_names array
			//
			if (instance_constructors != null)
				DefineMembers (instance_constructors, null);
		
			if (default_static_constructor != null)
				default_static_constructor.Define (this);
			
			if (methods != null)
				DefineMembers (methods, defined_names);

			if (properties != null)
				DefineMembers (properties, defined_names);

			if (events != null)
				DefineMembers (events, defined_names);

			if (indexers != null) {
				DefineIndexers ();
			} else
				IndexerName = "Item";

			if (operators != null){
				DefineMembers (operators, null);

				CheckPairedOperators ();
			}

			if (enums != null)
				DefineMembers (enums, defined_names);
			
			if (delegates != null)
				DefineMembers (delegates, defined_names);

#if CACHE
			if (TypeBuilder.BaseType != null)
				parent_container = TypeManager.LookupMemberContainer (TypeBuilder.BaseType);

			member_cache = new MemberCache (this);
#endif

			return true;
		}
Example #49
0
		/// <summary>
		///   Create a new MemberCache for the given IMemberContainer `container'.
		/// </summary>
		public MemberCache (IMemberContainer container)
		{
			this.Container = container;

			Timer.IncrementCounter (CounterType.MemberCache);
			Timer.StartTimer (TimerType.CacheInit);

			// If we have a base class (we have a base class unless we're
			// TypeManager.object_type), we deep-copy its MemberCache here.
			if (Container.BaseCache != null)
				member_hash = SetupCache (Container.BaseCache);
			else
				member_hash = new Hashtable ();

			// If this is neither a dynamic type nor an interface, create a special
			// method cache with all declared and inherited methods.
			Type type = container.Type;
			if (!(type is TypeBuilder) && !type.IsInterface &&
			    // !(type.IsGenericType && (type.GetGenericTypeDefinition () is TypeBuilder)) &&
			    !TypeManager.IsGenericType (type) && !TypeManager.IsGenericParameter (type) &&
			    (Container.BaseCache == null || Container.BaseCache.method_hash != null)) {
				method_hash = new Hashtable ();
				AddMethods (type);
			}

			// Add all members from the current class.
			AddMembers (Container);

			Timer.StopTimer (TimerType.CacheInit);
		}
Example #50
0
		public MemberCache (Type baseType, IMemberContainer container)
		{
			this.Container = container;
			if (baseType == null)
				this.member_hash = new Hashtable ();
			else
				this.member_hash = SetupCache (TypeManager.LookupMemberCache (baseType));
		}
Example #51
0
		public MemberCache (Type[] ifaces)
		{
			//
			// The members of this cache all belong to other caches.  
			// So, 'Container' will not be used.
			//
			this.Container = null;

			member_hash = new Hashtable ();
			if (ifaces == null)
				return;

			foreach (Type itype in ifaces)
				AddCacheContents (TypeManager.LookupMemberCache (itype));
		}
Example #52
0
 public static IAnalysisItemView Make(IModuleContext context, IMemberContainer members, string name) {
     return Make(context, name, members.GetMember(context, name));
 }
Example #53
0
		public MemberCache (IMemberContainer container, Type base_class, Type[] ifaces)
		{
			this.Container = container;

			// If we have a base class (we have a base class unless we're
			// TypeManager.object_type), we deep-copy its MemberCache here.
			if (Container.BaseCache != null)
				member_hash = SetupCache (Container.BaseCache);
			else
				member_hash = new Hashtable ();

			if (base_class != null)
				AddCacheContents (TypeManager.LookupMemberCache (base_class));
			if (ifaces != null) {
				foreach (Type itype in ifaces) {
					MemberCache cache = TypeManager.LookupMemberCache (itype);
					if (cache != null)
						AddCacheContents (cache);
				}
			}
		}
Example #54
0
		/// <summary>
		///   Add all members from class `container' to the cache.
		/// </summary>
		void AddMembers (IMemberContainer container)
		{
			// We need to call AddMembers() with a single member type at a time
			// to get the member type part of CacheEntry.EntryType right.
			if (!container.IsInterface) {
				AddMembers (MemberTypes.Constructor, container);
				AddMembers (MemberTypes.Field, container);
			}
			AddMembers (MemberTypes.Method, container);
			AddMembers (MemberTypes.Property, container);
			AddMembers (MemberTypes.Event, container);
			// Nested types are returned by both Static and Instance searches.
			AddMembers (MemberTypes.NestedType,
				    BindingFlags.Static | BindingFlags.Public, container);
			AddMembers (MemberTypes.NestedType,
				    BindingFlags.Static | BindingFlags.NonPublic, container);
		}
Example #55
0
 void ITypeDatabaseReader.ReadMember(string memberName, Dictionary<string, object> memberValue, Action<string, IMember> assign, IMemberContainer container) {
     _sharedState.ReadMember(memberName, memberValue, assign, container);
 }
Example #56
0
		void AddMembers (MemberTypes mt, IMemberContainer container)
		{
			AddMembers (mt, BindingFlags.Static | BindingFlags.Public, container);
			AddMembers (mt, BindingFlags.Static | BindingFlags.NonPublic, container);
			AddMembers (mt, BindingFlags.Instance | BindingFlags.Public, container);
			AddMembers (mt, BindingFlags.Instance | BindingFlags.NonPublic, container);
		}
Example #57
0
 public CJMethodDescriptor(ITypeDatabaseReader typeDb, string name, Dictionary<string, object> valueDict, IMemberContainer declaringType)
 {
     _name = name;
     _func = new CJFunction(typeDb, name, valueDict, declaringType, isMethod: true);
 }
Example #58
0
        void ITypeDatabaseReader.ReadMember(string memberName, Dictionary<string, object> memberValue, Action<string, IMember> assign, IMemberContainer container, JTypeDatabase instanceDb)
        {
            Debug.Assert(instanceDb == null);

            _sharedState.ReadMember(memberName, memberValue, assign, container, this);
        }