public override IMember GetMember(string name) { IMember member; lock (_lock) { if (Members.TryGetValue(name, out member)) { return(member); } // Special case names that we want to add to our own Members dict switch (name) { case "__mro__": member = AddMember(name, PythonCollectionType.CreateList(DeclaringModule.Interpreter, LocationInfo.Empty, Mro), true); return(member); } } if (Push()) { try { foreach (var m in Mro.Reverse()) { if (m == this) { return(member); } member = member ?? m.GetMember(name); } } finally { Pop(); } } return(null); }
// Constructor call public override IMember CreateInstance(IArgumentSet args) { var builtins = DeclaringModule.Interpreter.ModuleResolution.BuiltinsModule; // Specializations switch (Name) { case "list": return(PythonCollectionType.CreateList(builtins, args)); case "dict": { // self, then contents var contents = args.Values <IMember>().Skip(1).FirstOrDefault(); return(new PythonDictionary(builtins, contents)); } case "tuple": { var contents = args.Values <IMember>(); return(PythonCollectionType.CreateTuple(builtins, contents)); } } // Metaclasses return type, not instance. if (Bases.MaybeEnumerate().Any(b => b.Name == "type" && b.DeclaringModule.ModuleType == ModuleType.Builtins)) { return(this); } return(new PythonInstance(this)); }
public override IMember GetMember(string name) { lock (MembersLock) { if (Members.TryGetValue(name, out var member)) { return(member); } } // Special case names that we want to add to our own Members dict var is3x = DeclaringModule.Interpreter.LanguageVersion.Is3x(); switch (name) { case "__mro__": case "mro": return(is3x ? PythonCollectionType.CreateList(DeclaringModule, Mro) : UnknownType as IMember); case "__dict__": return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Dict) : UnknownType); case @"__weakref__": return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object) : UnknownType); } using (_memberGuard.Push(this, out var reentered)) { if (!reentered) { return(Mro.Skip(1).Select(c => c.GetMember(name)).ExcludeDefault().FirstOrDefault()); } return(null); } }
public IMember GetValueFromList(ListExpression expression) { var contents = new List <IMember>(); foreach (var item in expression.Items) { var value = GetValueFromExpression(item) ?? UnknownType; contents.Add(value); } return(PythonCollectionType.CreateList(Module.Interpreter, GetLoc(expression), contents)); }
public IMember GetValueFromList(ListExpression expression) { var contents = new List <IMember>(); foreach (var item in expression.Items.Take(MaxCollectionSize)) { var value = GetValueFromExpression(item) ?? UnknownType; contents.Add(value); } return(PythonCollectionType.CreateList(Module, contents, exact: expression.Items.Count <= MaxCollectionSize)); }
public async Task <IMember> GetValueFromListAsync(ListExpression expression, CancellationToken cancellationToken = default) { var contents = new List <IMember>(); foreach (var item in expression.Items) { var value = await GetValueFromExpressionAsync(item, cancellationToken) ?? UnknownType; contents.Add(value); } return(PythonCollectionType.CreateList(Module.Interpreter, GetLoc(expression), contents)); }
private void HandleAllAppendExtend(CallExpression node) { if (!(node.Target is MemberExpression me)) { return; } if (!IsHandleableAll(me.Target)) { return; } if (node.Args.Count == 0) { return; } var arg = node.Args[0].Expression; var v = Eval.GetValueFromExpression(arg); if (v == null) { _allIsUsable = false; return; } IPythonCollection values = null; switch (me.Name) { case "append": values = PythonCollectionType.CreateList(Module.Interpreter, Eval.GetLoc(arg), new List <IMember>() { v }, exact: true); break; case "extend": values = v as IPythonCollection; break; } if (values == null) { _allIsUsable = false; return; } ExtendAll(node, values); }
private IEnumerable <IPythonType> CreateBases(ClassModel cm, ModuleFactory mf, IGlobalScope gs) { var ntBases = cm.NamedTupleBases .Select(ntb => MemberFactory.CreateMember(ntb, ModuleFactory, GlobalScope, _cls)) .OfType <IPythonType>() .ToArray(); var is3x = mf.Module.Interpreter.LanguageVersion.Is3x(); var basesNames = cm.Bases.Select(b => is3x && b == "object" ? null : b).ExcludeDefault().ToArray(); var bases = basesNames.Select(mf.ConstructType).ExcludeDefault().Concat(ntBases).ToArray(); // Make sure base types are realized foreach (var b in bases.OfType <PythonLazyClassType>()) { b.EnsureContent(); } if (cm.GenericBaseParameters.Length > 0) { // Generic class. Need to reconstruct generic base so code can then // create specific types off the generic class. var genericBase = bases.OfType <IGenericType>().FirstOrDefault(b => b.Name == "Generic"); if (genericBase != null) { var typeVars = cm.GenericBaseParameters.Select(n => gs.Variables[n]?.Value).OfType <IGenericTypeParameter>().ToArray(); //Debug.Assert(typeVars.Length > 0, "Class generic type parameters were not defined in the module during restore"); if (typeVars.Length > 0) { var genericWithParameters = genericBase.CreateSpecificType(new ArgumentSet(typeVars, null, null)); if (genericWithParameters != null) { bases = bases.Except(Enumerable.Repeat(genericBase, 1)).Concat(Enumerable.Repeat(genericWithParameters, 1)).ToArray(); } } } else { Debug.Fail("Generic class does not have generic base."); } } if (bases.Length > 0) { _cls.AddMember("__base__", bases[0], true); } _cls.AddMember("__bases__", PythonCollectionType.CreateList(DeclaringModule.Interpreter.ModuleResolution.BuiltinsModule, bases), true); return(bases); }
/// <summary> /// Sets class bases. If scope is provided, detects loops in base classes and removes them. /// </summary> /// <param name="bases">List of base types.</param> /// <param name="currentScope">Current scope to look up base types. /// Can be null if class is restored from database, in which case /// there is no need to try and disambiguate bases.</param> internal void SetBases(IEnumerable <IPythonType> bases, IScope currentScope = null) { if (_bases != null) { return; // Already set } // Consider // from X import A // class A(A): ... bases = DisambiguateBases(bases, currentScope).ToArray(); // For Python 3+ attach object as a base class by default except for the object class itself. if (DeclaringModule.Interpreter.LanguageVersion.Is3x() && DeclaringModule.ModuleType != ModuleType.Builtins) { var objectType = DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object); // During processing of builtins module some types may not be available yet. // Specialization will attach proper base at the end. Debug.Assert(!objectType.IsUnknown()); if (!bases.Any(b => objectType.Equals(b))) { bases = bases.Concat(Enumerable.Repeat(objectType, 1)); } } _bases = bases.ToList(); if (_bases.Count > 0) { AddMember("__base__", _bases[0], true); } // Invalidate MRO _mro = null; DecideGeneric(); if (DeclaringModule is BuiltinsPythonModule) { // TODO: If necessary, we can set __bases__ on builtins when the module is fully analyzed. return; } AddMember("__bases__", PythonCollectionType.CreateList(DeclaringModule.Interpreter.ModuleResolution.BuiltinsModule, _bases), true); }
public override IMember GetMember(string name) { IMember member; lock (_lock) { if (Members.TryGetValue(name, out member)) { return(member); } // Special case names that we want to add to our own Members dict var is3x = DeclaringModule.Interpreter.LanguageVersion.Is3x(); switch (name) { case "__mro__": case "mro": return(is3x ? PythonCollectionType.CreateList(DeclaringModule.Interpreter, LocationInfo.Empty, Mro) : UnknownType); case "__dict__": return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Dict) : UnknownType); case @"__weakref__": return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object) : UnknownType); } } if (Push(this)) { try { foreach (var m in Mro.Reverse()) { if (m == this) { return(member); } member = member ?? m.GetMember(name); } } finally { Pop(); } } return(null); }
public IMember GetValueFromComprehension(Comprehension node) { var oldVariables = CurrentScope.Variables.OfType <Variable>().ToDictionary(k => k.Name, v => v); try { ProcessComprehension(node); // TODO: Evaluate comprehensions to produce exact contents, if possible. switch (node) { case ListComprehension lc: var v1 = GetValueFromExpression(lc.Item) ?? UnknownType; return(PythonCollectionType.CreateList(Module, new[] { v1 })); case SetComprehension sc: var v2 = GetValueFromExpression(sc.Item) ?? UnknownType; return(PythonCollectionType.CreateSet(Module, new[] { v2 })); case DictionaryComprehension dc: var k = GetValueFromExpression(dc.Key) ?? UnknownType; var v = GetValueFromExpression(dc.Value) ?? UnknownType; return(new PythonDictionary(new PythonDictionaryType(Interpreter.ModuleResolution.BuiltinsModule), new Dictionary <IMember, IMember> { { k, v } })); } return(UnknownType); } finally { // Remove temporary variables since this is assignment and the right hand // side comprehension does not leak internal variables into the scope. var newVariables = CurrentScope.Variables.ToDictionary(k => k.Name, v => v); var variables = (VariableCollection)CurrentScope.Variables; foreach (var kvp in newVariables) { if (!oldVariables.ContainsKey(kvp.Key)) { variables.RemoveVariable(kvp.Key); } } } }
// Constructor call public override IMember CreateInstance(string typeName, IArgumentSet args) { // Specializations switch (typeName) { case "list": return(PythonCollectionType.CreateList(DeclaringModule.Interpreter, args)); case "dict": { // self, then contents var contents = args.Values <IMember>().Skip(1).FirstOrDefault(); return(new PythonDictionary(DeclaringModule.Interpreter, contents)); } case "tuple": { var contents = args.Values <IMember>(); return(PythonCollectionType.CreateTuple(DeclaringModule.Interpreter, contents)); } } return(new PythonInstance(this)); }
internal void SetBases(IPythonInterpreter interpreter, IEnumerable <IPythonType> bases) { lock (_lock) { if (Bases != null) { return; // Already set } Bases = bases.MaybeEnumerate().ToArray(); if (Bases.Count > 0) { AddMember("__base__", Bases[0], true); } if (!(DeclaringModule is BuiltinsPythonModule)) { // TODO: If necessary, we can set __bases__ on builtins when the module is fully analyzed. AddMember("__bases__", PythonCollectionType.CreateList(DeclaringModule.Interpreter, LocationInfo.Empty, Bases), true); } } }
internal void SetBases(IEnumerable <IPythonType> bases) { lock (_lock) { if (_bases != null) { return; // Already set } bases = bases != null?bases.Where(b => !b.GetPythonType().IsUnknown()).ToArray() : Array.Empty <IPythonType>(); // For Python 3+ attach object as a base class by default except for the object class itself. if (DeclaringModule.Interpreter.LanguageVersion.Is3x() && DeclaringModule.ModuleType != ModuleType.Builtins) { var objectType = DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object); // During processing of builtins module some types may not be available yet. // Specialization will attach proper base at the end. Debug.Assert(!objectType.IsUnknown()); if (!bases.Any(b => objectType.Equals(b))) { bases = bases.Concat(Enumerable.Repeat(objectType, 1)); } } _bases = bases.ToList(); if (_bases.Count > 0) { AddMember("__base__", _bases[0], true); } // Invalidate MRO _mro = null; if (DeclaringModule is BuiltinsPythonModule) { // TODO: If necessary, we can set __bases__ on builtins when the module is fully analyzed. return; } AddMember("__bases__", PythonCollectionType.CreateList(DeclaringModule.Interpreter, LocationInfo.Empty, _bases), true); } }
public override IMember GetMember(string name) { // Push/Pop should be lock protected. if (Members.TryGetValue(name, out var member)) { return(member); } // Special case names that we want to add to our own Members dict var is3x = DeclaringModule.Interpreter.LanguageVersion.Is3x(); switch (name) { case "__mro__": case "mro": return(is3x ? PythonCollectionType.CreateList(DeclaringModule.Interpreter, Mro) : UnknownType as IMember); case "__dict__": return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Dict) : UnknownType); case @"__weakref__": return(is3x ? DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object) : UnknownType); } using (_memberGuard.Push(this, out var reentered)) { if (!reentered) { foreach (var m in Mro.Reverse()) { if (m == this) { return(member); } member = member ?? m.GetMember(name); } } return(null); } }
// Constructor call public override IPythonInstance CreateInstance(IArgumentSet args) { var builtins = DeclaringModule.Interpreter.ModuleResolution.BuiltinsModule; // Specializations switch (Name) { case "list": return(PythonCollectionType.CreateList(builtins, args)); case "dict": { // self, then contents var contents = args.Values <IMember>().Skip(1).FirstOrDefault(); return(new PythonDictionary(builtins, contents)); } case "tuple": { var contents = args.Values <IMember>(); return(PythonCollectionType.CreateTuple(builtins, contents)); } } return(new PythonInstance(this)); }
public static IMember List(IPythonInterpreter interpreter, IPythonFunctionOverload overload, LocationInfo location, IReadOnlyList <IMember> args) => PythonCollectionType.CreateList(interpreter, location, args);
public static IMember List(IPythonInterpreter interpreter, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) => PythonCollectionType.CreateList(interpreter.ModuleResolution.BuiltinsModule, argSet);
private IPythonCollection CreateList(IReadOnlyList <IMember> items) => PythonCollectionType.CreateList(Type.DeclaringModule.Interpreter, items, false);
public static IMember List(IPythonInterpreter interpreter, IPythonFunctionOverload overload, LocationInfo location, IArgumentSet argSet) => PythonCollectionType.CreateList(interpreter, location, argSet);