private IAnalysisSet GetFunction(Node node, AnalysisUnit unit, string name, CallDelegate callable)
        {
            lock (_callables) {
                if (_callables.TryGetValue(name, out var res))
                {
                    return(res);
                }
            }
            if (unit.ForEval)
            {
                return(null);
            }

            var inner = _inner.GetMember(node, unit, name).OfType <BuiltinFunctionInfo>().FirstOrDefault();

            lock (_callables) {
                return(_callables[name] = new SpecializedCallable(inner, callable, false));
            }
        }
Ejemplo n.º 2
0
        public override IAnalysisSet GetMember(Node node, AnalysisUnit unit, string name)
        {
            IAnalysisSet res = null;

            switch (name)
            {
            case "Any":
                res = AnalysisSet.Empty;
                break;

            case "Callable":
            case "Generic":
            case "Optional":
            case "Tuple":
            case "TypeVar":
            case "Union":
            case "Container":
            case "ItemsView":
            case "Iterable":
            case "Iterator":
            case "KeysView":
            case "Mapping":
            case "MappingView":
            case "MutableMapping":
            case "MutableSequence":
            case "MutableSet":
            case "Sequence":
            case "ValuesView":
            case "Dict":
            case "List":
            case "Set":
            case "FrozenSet":
            case "NamedTuple":
            case "Generator":
            case "ClassVar":
                res = new TypingTypeInfo(name);
                break;

            case "AbstractSet": break;

            case "GenericMeta": break;

            // As our purposes are purely informational, it's okay to
            // "round up" to the nearest type. That said, proper protocol
            // support would be nice to implement.
            case "ContextManager": break;

            case "Hashable": break;

            case "Reversible": break;

            case "SupportsAbs": break;

            case "SupportsBytes": res = GetBuiltin(BuiltinTypeId.Bytes); break;

            case "SupportsComplex": res = GetBuiltin(BuiltinTypeId.Complex); break;

            case "SupportsFloat": res = GetBuiltin(BuiltinTypeId.Float); break;

            case "SupportsInt": res = GetBuiltin(BuiltinTypeId.Int); break;

            case "SupportsRound": break;

            case "Sized": break;

            case "Counter": res = Import("collections", "Counter", node, unit); break;

            case "Deque": res = Import("collections", "deque", node, unit); break;

            case "DefaultDict": res = Import("collections", "defaultdict", node, unit); break;

            case "Type": res = GetBuiltin(BuiltinTypeId.Type); break;

            case "ByteString": res = GetBuiltin(BuiltinTypeId.Bytes); break;

            case "AnyStr": res = GetBuiltin(BuiltinTypeId.Unicode).Union(GetBuiltin(BuiltinTypeId.Bytes), canMutate: false); break;

            case "Text": res = GetBuiltin(BuiltinTypeId.Str); break;

                // The following are added depending on presence
                // of their non-generic counterparts in stdlib:
                // Awaitable
                // AsyncIterator
                // AsyncIterable
                // Coroutine
                // Collection
                // AsyncGenerator
                // AsyncContextManager
            }

            return(res ?? _inner.GetMember(node, unit, name));
        }