public static IMember CreateMember(MemberModel model, ModuleFactory mf, IGlobalScope gs, IPythonType declaringType)
{
var unkType = mf.Module.Interpreter.UnknownType;
switch (model)
{
case ClassModel cm:
return(new PythonLazyClassType(cm, mf, gs, declaringType));
case FunctionModel fm:
return(new PythonLazyFunctionType(fm, mf, gs, declaringType));
case PropertyModel pm:
return(new PythonLazyPropertyType(pm, mf, gs, declaringType));
case NamedTupleModel ntm:
var itemTypes = ntm.ItemTypes.Select(n => mf.ConstructType(n) ?? unkType).ToArray();
return(new NamedTupleType(ntm.Name, ntm.ItemNames, itemTypes, mf.Module, ntm.IndexSpan.ToSpan()));
case TypeVarModel tvm:
return(new GenericTypeParameter(tvm.Name, mf.Module,
tvm.Constraints.Select(n => mf.ConstructType(n) ?? unkType).ToArray(),
mf.ConstructType(tvm.Bound), tvm.Covariant, tvm.Contravariant, default));
case VariableModel vm:
var m = mf.ConstructMember(vm.Value) ?? unkType;
return(new Variable(vm.Name, m, VariableSource.Declaration, new Location(mf.Module, vm.IndexSpan?.ToSpan() ?? default)));
}
Debug.Fail("Unsupported model type.");
return(null);
}
public override void Populate(ModuleFactory mf, IPythonType declaringType, IGlobalScope gs)
{
_property.SetDocumentation(Documentation);
var o = new PythonFunctionOverload(_property, mf.DefaultLocation);
o.SetDocumentation(Documentation);
o.SetReturnValue(mf.ConstructMember(ReturnType), true);
_property.AddOverload(o);
}
private void EnsureContent()
{
lock (_contentLock) {
if (_model != null)
{
_overload.SetParameters(_model.Parameters.Select(p => ConstructParameter(_mf, p)).ToArray());
_overload.SetReturnValue(_mf.ConstructMember(_model.ReturnType), true);
_model = null;
_mf = null;
}
}
}
public override void Populate(ModuleFactory mf, IPythonType declaringType, IGlobalScope gs)
{
// Create inner functions and classes first since function may be returning one of them.
var all = Classes.Concat <MemberModel>(Functions).ToArray();
foreach (var model in all)
{
_function.AddMember(Name, model.Create(mf, _function, gs), overwrite: true);
}
foreach (var model in all)
{
model.Populate(mf, _function, gs);
}
foreach (var om in Overloads)
{
var o = new PythonFunctionOverload(_function, new Location(mf.Module, IndexSpan.ToSpan()));
o.SetDocumentation(Documentation);
o.SetReturnValue(mf.ConstructMember(om.ReturnType), true);
o.SetParameters(om.Parameters.Select(p => ConstructParameter(mf, p)).ToArray());
_function.AddOverload(o);
}
}
protected override void EnsureContent(PropertyModel pm)
{
_property.Getter.SetReturnValue(ModuleFactory.ConstructMember(pm.ReturnType), true);
}
private IParameterInfo ConstructParameter(ModuleFactory mf, ParameterModel pm) => new ParameterInfo(pm.Name, mf.ConstructType(pm.Type), pm.Kind, mf.ConstructMember(pm.DefaultValue));
public override IMember Create(ModuleFactory mf, IPythonType declaringType, IGlobalScope gs)
{
var m = mf.ConstructMember(Value) ?? mf.Module.Interpreter.UnknownType;
return(new Variable(Name, m, VariableSource.Declaration, new Location(mf.Module, IndexSpan?.ToSpan() ?? default)));
}
