private PythonType CheckGetArgs(CodeContext context, object instance, PythonType owner)
{
if (owner == null)
{
if (instance == null)
{
throw PythonOps.TypeError("__get__(None, None) is invalid");
}
owner = DynamicHelpers.GetPythonType(instance);
}
else
{
if (!owner.IsSubclassOf(DynamicHelpers.GetPythonTypeFromType(_func.DeclaringType)))
{
throw PythonOps.TypeError("descriptor {0} for type {1} doesn't apply to type {2}",
PythonOps.Repr(context, _func.Name),
PythonOps.Repr(context, DynamicHelpers.GetPythonTypeFromType(_func.DeclaringType).Name),
PythonOps.Repr(context, owner.Name));
}
}
if (instance != null)
{
BuiltinMethodDescriptor.CheckSelfWorker(context, instance, _func);
}
return(owner);
}
public void __init__(PythonType type, object obj)
{
if (obj != null)
{
PythonType dt = obj as PythonType;
if (PythonOps.IsInstance(obj, type))
{
this._thisClass = type;
this._self = obj;
this._selfClass = DynamicHelpers.GetPythonType(obj);
}
else if (dt != null && dt.IsSubclassOf(type))
{
this._thisClass = type;
this._selfClass = obj;
this._self = obj;
}
else
{
throw PythonOps.TypeError("super(type, obj): obj must be an instance or subtype of type {1}, not {0}", PythonTypeOps.GetName(obj), type.Name);
}
}
else
{
this._thisClass = type;
this._self = null;
this._selfClass = null;
}
}
private void ValidateArgs(object[] args)
{
int start = 0;
if (_inst != null)
{
start = 1;
}
// no need to validate self... the method should handle it.
for (int i = start; i < args.Length + start; i++)
{
PythonType dt = DynamicHelpers.GetPythonType(args[i - start]);
PythonType expct = _expected[i] as PythonType;
if (expct == null)
{
expct = ((OldClass)_expected[i]).TypeObject;
}
if (dt != _expected[i] && !dt.IsSubclassOf(expct))
{
throw PythonOps.AssertionError("argument {0} has bad value (got {1}, expected {2})", i, dt, _expected[i]);
}
}
}
public static PythonModule /*!*/ __new__(CodeContext /*!*/ context, PythonType /*!*/ cls, params object[] /*!*/ args\u00F8)
{
PythonModule res;
if (cls == TypeCache.Module)
{
res = new PythonModule();
}
else if (cls.IsSubclassOf(TypeCache.Module))
{
res = (PythonModule)cls.CreateInstance(context);
}
else
{
throw PythonOps.TypeError("{0} is not a subtype of module", cls.Name);
}
return(res);
}
private void ValidateReturn(object ret)
{
// we return void...
if (ret == null && _retType == null)
{
return;
}
PythonType dt = DynamicHelpers.GetPythonType(ret);
if (dt != _retType)
{
PythonType expct = _retType as PythonType;
if (expct == null)
{
expct = ((OldClass)_retType).TypeObject;
}
if (!dt.IsSubclassOf(expct))
{
throw PythonOps.AssertionError("bad return value returned (expected {0}, got {1})", _retType, dt);
}
}
}
private void CheckSelf(object self)
{
// if the type has been re-optimized (we also have base type info in here)
// then we can't do the type checks right now :(.
if ((template.FunctionType & FunctionType.SkipThisCheck) != 0)
{
return;
}
if ((template.FunctionType & FunctionType.FunctionMethodMask) == FunctionType.Method)
{
// to a fast check on the CLR types, if they match we can avoid the slower
// check that involves looking up dynamic types.
if (self.GetType() == template.ClrDeclaringType)
{
return;
}
PythonType selfType = Ops.GetDynamicTypeFromType(self.GetType()) as PythonType;
Debug.Assert(selfType != null);
ReflectedType declType = DeclaringType;
if (!selfType.IsSubclassOf(declType))
{
// if a conversion exists to the type allow the call.
Conversion conv;
if (Converter.TryConvert(self, declType.type, out conv) == null)
{
throw Ops.TypeError("descriptor {0} requires a {1} object but received a {2}",
Ops.Repr(Name),
Ops.Repr(DeclaringType.__name__),
Ops.Repr(Ops.GetDynamicType(self).__name__));
}
}
}
}
