public static IMember TypeInfo(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var args = argSet.Values <IMember>(); var t = args.Count > 0 ? args[0].GetPythonType() : module.Interpreter.GetBuiltinType(BuiltinTypeId.Type); return(t.ToBound()); }
public static IMember GetAttr(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { // TODO: Try __getattr__ first; this may not be as reliable in practice // given we could be assuming that __getattr__ always returns the same type, // which is incorrect more often than not. var args = argSet.Values <IMember>(); if (args.Count < 2) { return(null); } var o = args[0]; var name = (args[1] as IPythonConstant)?.GetString(); IMember def = null; if (args.Count >= 3) { def = args[2]; } // second argument to getattr was not a string, which is a runtime error // getattr(a, 3.14) if (name == null) { // TODO diagnostic error when second arg of getattr is not a string return(module.Interpreter.UnknownType); } return(o?.GetPythonType().GetMember(name) ?? def); }
public void AddOverload(IPythonFunctionOverload overload) { if (_getter == null) { _getter = overload; } }
public static IMember Open(IPythonModule declaringModule, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var mode = argSet.GetArgumentValue <IPythonConstant>("mode"); var binary = false; var writable = false; var readWrite = false; var modeString = mode?.GetString(); if (modeString != null) { binary = modeString.Contains("b"); writable = modeString.Contains("w") || modeString.Contains("a") || modeString.Contains("x"); readWrite = writable && modeString.Contains("r"); } string returnTypeName; var io = declaringModule.Interpreter.ModuleResolution.GetImportedModule("io"); if (binary) { returnTypeName = writable ? readWrite ? "BufferedRandom" : "BufferedWriter" : "BufferedReader"; } else { returnTypeName = "TextIOWrapper"; } var returnType = io?.GetMember(returnTypeName)?.GetPythonType(); return(returnType != null?returnType.CreateInstance(argSet) : null); }
public static IMember GetAttr(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet) { // TODO: Try __getattr__ first; this may not be as reliable in practice // given we could be assuming that __getattr__ always returns the same type, // which is incorrect more often than not. var args = argSet.Values <IMember>(); if (args.Count < 2) { return(null); } var o = args[0]; var name = (args[1] as IPythonConstant)?.GetString(); IMember def = null; if (args.Count >= 3) { def = args[2]; } if (name == null) { return(def); } return(o?.GetPythonType().GetMember(name) ?? def); }
public static IMember DictStringToObject(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var str = module.Interpreter.GetBuiltinType(BuiltinTypeId.Str); var obj = module.Interpreter.GetBuiltinType(BuiltinTypeId.Object); var type = new TypingDictionaryType("Dict", str, obj, module.Interpreter, false); return(new TypingDictionary(type)); }
public static IMember DictStringToObject(IPythonModule module, IPythonFunctionOverload overload, LocationInfo location, IReadOnlyList <IMember> args) { var str = module.Interpreter.GetBuiltinType(BuiltinTypeId.Str); var obj = module.Interpreter.GetBuiltinType(BuiltinTypeId.Object); var type = new TypingDictionaryType("Dict", str, obj, module.Interpreter, false); return(new TypingDictionary(type, location)); }
public FunctionOverloadView(IModuleContext context, string name, IPythonFunctionOverload overload) { _context = context; Name = name; _overload = overload; _prototype = new Lazy<string>(CalculatePrototype); _returnTypes = new Lazy<IEnumerable<IAnalysisItemView>>(CalculateReturnTypes); _parameters = new Lazy<IEnumerable<IAnalysisItemView>>(CalculateParameters); }
public FunctionOverloadView(IModuleContext context, string name, IPythonFunctionOverload overload) { _context = context; Name = name; _overload = overload; _prototype = new Lazy <string>(CalculatePrototype); _returnTypes = new Lazy <IEnumerable <IAnalysisItemView> >(CalculateReturnTypes); _parameters = new Lazy <IEnumerable <IAnalysisItemView> >(CalculateParameters); }
private static CompletionItem ToOverrideCompletionItem(IPythonFunctionOverload o, ClassDefinition cd, CompletionContext context, string indent) { return(new CompletionItem { label = o.Name, insertText = MakeOverrideCompletionString(indent, o, cd.Name, context), insertTextFormat = InsertTextFormat.PlainText, kind = CompletionItemKind.Method }); }
internal BuiltinFunctionOverloadResult(PythonAnalyzer state, IPythonFunctionOverload overload, int removedParams, string name, params ParameterResult[] extraParams) : base(null, name) { _overload = overload; _extraParameters = extraParams; _removedParams = removedParams; _projectState = state; CalculateDocumentation(); }
public static IMember Range(IPythonModule module, IPythonFunctionOverload overload, LocationInfo location, IArgumentSet argSet) { var args = argSet.Values <IMember>(); if (args.Count > 0) { var type = new PythonCollectionType(null, BuiltinTypeId.List, module.Interpreter, false); return(new PythonCollection(type, location, new[] { args[0] })); } return(null); }
private static OverloadModel FromOverload(IPythonFunctionOverload o) => new OverloadModel { Parameters = o.Parameters.Select(p => new ParameterModel { Name = p.Name, Type = p.Type.GetPersistentQualifiedName(), Kind = p.Kind, DefaultValue = p.DefaultValue.GetPersistentQualifiedName(), }).ToArray(), ReturnType = o.StaticReturnValue.GetPersistentQualifiedName() };
public static IMember Range(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var args = argSet.Values <IMember>(); if (args.Count > 0) { var type = new PythonCollectionType(BuiltinTypeId.List, module.Interpreter.ModuleResolution.BuiltinsModule, false); return(new PythonCollection(type, new[] { args[0] })); } return(null); }
internal BuiltinFunctionOverloadResult(PythonAnalyzer state, IPythonFunctionOverload overload, int removedParams, string name, Func <string> fallbackDoc, params ParameterResult[] extraParams) : base(null, name, null, null) { _overload = overload; _extraParameters = extraParams; _removedParams = removedParams; _projectState = state; _fallbackDoc = fallbackDoc; _returnTypes = Array.Empty <string>(); Calculate(); }
internal BuiltinFunctionOverloadResult(PythonAnalyzer state, string name, IPythonFunctionOverload overload, int removedParams, Func <string> fallbackDoc, params ParameterResult[] extraParams) : base(null, name, null, null) { _fallbackDoc = fallbackDoc; _overload = overload; _extraParameters = extraParams; _removedParams = removedParams; _projectState = state; _returnTypes = GetInstanceDescriptions(state, overload.ReturnType).OrderBy(n => n).Distinct().ToArray(); Calculate(); }
internal BuiltinFunctionOverloadResult(PythonAnalyzer state, string name, IPythonFunctionOverload overload, int removedParams, Func <string> fallbackDoc, params ParameterResult[] extraParams) : base(null, name, null, null) { _fallbackDoc = fallbackDoc; _overload = overload; _extraParameters = extraParams; _removedParams = removedParams; _projectState = state; _returnTypes = GetInstanceDescriptions(state, overload.ReturnType).OrderBy(n => n).Distinct().ToArray(); // initially fill in w/ a string saying we don't yet have the documentation _docTask = Task.Run(() => DocCalculator()); }
public static IMember Iterator(IPythonModule module, IPythonFunctionOverload overload, LocationInfo location, IReadOnlyList <IMember> args) { if (args.Count > 0) { if (args[0] is IPythonCollection seq) { return(seq.GetIterator()); } var t = args[0].GetPythonType(); if (t.IsBuiltin && t.Name == "str") { return(new PythonTypeIterator(BuiltinTypeId.StrIterator, BuiltinTypeId.Str, module.Interpreter)); } } return(null); }
/// <summary> /// Creates function type to use in special cases when function is dynamically /// created, such as in specializations and custom iterators, without the actual /// function definition in the AST. /// </summary> public PythonFunctionType( string name, IPythonModule declaringModule, IPythonType declaringType, Func <string, string> documentationProvider, Func <string, LocationInfo> locationProvider, IPythonFunctionOverload overload = null ) : base(name, declaringModule, documentationProvider, locationProvider, declaringType != null ? BuiltinTypeId.Method : BuiltinTypeId.Function) { DeclaringType = declaringType; if (overload != null) { AddOverload(overload); } }
private static string MakeOverrideCompletionString(string indentation, IPythonFunctionOverload overload, string className, CompletionContext context) { var sb = new StringBuilder(); var first = overload.Parameters.FirstOrDefault(); var fn = overload.ClassMember as IPythonFunctionType; var skipFirstParameters = fn?.IsStatic == true ? overload.Parameters : overload.Parameters.Skip(1); sb.AppendLine(overload.Name + "(" + string.Join(", ", overload.Parameters.Select(p => MakeOverrideParameter(p, p.DefaultValueString))) + "):"); sb.Append(indentation); if (overload.Parameters.Count > 0) { // Return in __init__ not good practice, only add return statement if overload is not __init__ if (!overload.Name.Equals("__init__")) { sb.Append("return "); } var parameterString = string.Join(", ", skipFirstParameters.Select(p => MakeOverrideParameter(p, p.Name))); if (context.Ast.LanguageVersion.Is3x()) { sb.AppendFormat("super().{0}({1})", overload.Name, parameterString); } else if (!string.IsNullOrEmpty(className)) { sb.AppendFormat("super({0}, {1}).{2}({3})", className, first?.Name ?? string.Empty, overload.Name, parameterString); } else { sb.Append("pass"); } } else { sb.Append("pass"); } return(sb.ToString()); }
public static IMember Open(IPythonModule declaringModule, IPythonFunctionOverload overload, LocationInfo location, IArgumentSet argSet) { var mode = argSet.GetArgumentValue <IPythonConstant>("mode"); var bytes = false; if (mode != null) { var modeString = mode.GetString(); bytes = modeString != null && modeString.Contains("b"); } var io = declaringModule.Interpreter.ModuleResolution.GetImportedModule("io"); var ioBase = io?.GetMember(bytes ? "BufferedIOBase" : "TextIOWrapper")?.GetPythonType(); return(ioBase != null ? new PythonInstance(ioBase) : null); }
public static IMember Iterator(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var args = argSet.Values <IMember>(); if (args.Count > 0) { if (args[0] is IPythonCollection seq) { return(seq.GetIterator()); } var t = args[0].GetPythonType(); if (t.IsBuiltin && t.Name == "str") { return(new PythonTypeIterator(BuiltinTypeId.StrIterator, BuiltinTypeId.Str, module.Interpreter)); } } return(null); }
public static IReadOnlyList <IPythonType> GetTypeArgumentsFromParameters(IPythonFunctionOverload o, IArgumentSet args) { if (o.Parameters.Any(p => p.IsGeneric)) { // Declaring class is not generic, but the function is and arguments // should provide actual specific types. // TODO: handle keyword and dict args var list = new List <IPythonType>(); for (var i = 0; i < Math.Min(o.Parameters.Count, args.Arguments.Count); i++) { if (o.Parameters[i].IsGeneric) { list.AddRange(GetSpecificTypeFromArgumentValue(args.Arguments[i].Value)); } } return(list); } return(null); }
public static IMember Super(IPythonModule declaringModule, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var args = argSet.Values <IMember>(); if (args.Count == 0) { //Zero argument form only works inside a class definition foreach (var s in argSet.Eval.CurrentScope.EnumerateTowardsGlobal.Where(s => s.Node is ClassDefinition)) { var classType = s.Variables["__class__"].GetPythonType <IPythonClassType>(); return(PythonSuperType.Create(classType)?.CreateInstance(argSet)); } return(null); } // If multiple arguments first argument is required var firstCls = args.FirstOrDefault().GetPythonType <IPythonClassType>(); if (firstCls == null) { return(null); } // second argument optional bool isUnbound = args.Count == 1; if (isUnbound) { return(PythonSuperType.Create(firstCls)?.CreateInstance(argSet)); } var secondCls = args[1].GetPythonType <IPythonClassType>(); if (secondCls?.Equals(firstCls) == true || secondCls?.IsSubClassOf(firstCls) == true) { // We walk the mro of the second parameter looking for the first return(PythonSuperType.Create(secondCls, typeToFind: firstCls)?.CreateInstance(argSet)); } return(null); }
internal BuiltinFunctionOverloadResult(PythonAnalyzer state, string name, IPythonFunctionOverload overload, int removedParams, Func <string> fallbackDoc, params ParameterResult[] extraParams) : base(null, name, null, null) { _fallbackDoc = fallbackDoc; _overload = overload; _extraParameters = extraParams; _removedParams = removedParams; _projectState = state; if (!overload.ReturnType.Any()) { _returnTypes = Array.Empty <string>(); } else { _returnTypes = overload.ReturnType.Select(t => state.GetAnalysisValueFromObjects(t)?.ShortDescription ?? t.Name).OrderBy(n => n).Distinct().ToArray(); } Calculate(); }
public static IMember ListOfStrings(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var type = new TypingListType("List", module.Interpreter.GetBuiltinType(BuiltinTypeId.Str), module.Interpreter, false); return(new TypingList(type)); }
internal void AddOverload(IPythonFunctionOverload overload) => _getter = _getter ?? overload;
internal BuiltinFunctionOverloadResult(PythonAnalyzer state, string name, IPythonFunctionOverload overload, int removedParams, params ParameterResult[] extraParams) : this(state, name, overload, removedParams, null, extraParams) { }
public static IMember Identity(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var args = argSet.Values <IMember>(); return(args.Count > 0 ? args.FirstOrDefault(a => !a.IsUnknown()) ?? args[0] : null); }
public static IMember List(IPythonInterpreter interpreter, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) => PythonCollectionType.CreateList(interpreter.ModuleResolution.BuiltinsModule, argSet);
public static IMember Next(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var args = argSet.Values <IMember>(); return(args.Count > 0 && args[0] is IPythonIterator it ? it.Next : null); }