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);
}
