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 IPythonType FromTypeVar(IArgumentSet argSet, IPythonModule declaringModule, IndexSpan indexSpan = default)
{
if (!TypeVarArgumentsValid(argSet))
{
return(declaringModule.Interpreter.UnknownType);
}
var constraintArgs = argSet.ListArgument?.Values ?? Array.Empty <IMember>();
var name = argSet.GetArgumentValue <IPythonConstant>("name")?.GetString();
var constraints = constraintArgs.Select(a => {
// Type constraints may be specified as type name strings.
var typeString = a.GetString();
return(!string.IsNullOrEmpty(typeString) ? argSet.Eval.GetTypeFromString(typeString) : a.GetPythonType());
}).ToArray();
var bound = GetBoundType(argSet);
var covariant = argSet.GetArgumentValue <IPythonConstant>("covariant")?.Value;
var contravariant = argSet.GetArgumentValue <IPythonConstant>("contravariant")?.Value;
return(new GenericTypeParameter(name, declaringModule, constraints, bound, covariant, contravariant, indexSpan));
}
/// <summary>
/// Given arguments to TypeVar, finds the bound type
/// </summary>
private static IPythonType GetBoundType(IArgumentSet argSet)
{
var eval = argSet.Eval;
var rawBound = argSet.GetArgumentValue <IMember>("bound");
switch (rawBound)
{
case IPythonType t:
return(t);
case IPythonConstant c when c.GetString() != null:
return(eval.GetTypeFromString(c.GetString()));
default:
return(rawBound.GetPythonType());
}
}
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);
}
/// <summary>
/// Given arguments to TypeVar, finds the bound type
/// </summary>
private static IPythonType GetBoundType(IArgumentSet argSet)
{
var eval = argSet.Eval;
var rawBound = argSet.GetArgumentValue <IMember>("bound");
switch (rawBound)
{
case IPythonType t:
return(t);
case IPythonConstant c:
var s = c.GetString();
if (!string.IsNullOrEmpty(s))
{
return(eval.GetTypeFromString(s) ?? argSet.Eval.UnknownType);
}
return(argSet.Eval.UnknownType);
default:
return(rawBound.GetPythonType());
}
}
