internal static void DeclareParametersInScope(this IArgumentSet args, ExpressionEval eval)
{
if (eval == null)
{
return;
}
// For class method no need to add extra parameters, but first parameter type should be the class.
// For static and unbound methods do not add or set anything.
// For regular bound methods add first parameter and set it to the class.
foreach (var a in args.Arguments)
{
if (a.Value is IMember m && !string.IsNullOrEmpty(a.Name))
{
eval.DeclareVariable(a.Name, m, VariableSource.Declaration, a.Location);
}
}
if (args.ListArgument != null && !string.IsNullOrEmpty(args.ListArgument.Name))
{
var type = new PythonCollectionType(null, BuiltinTypeId.List, eval.Interpreter, false);
var list = new PythonCollection(type, args.ListArgument.Values);
eval.DeclareVariable(args.ListArgument.Name, list, VariableSource.Declaration, args.ListArgument.Location);
}
if (args.DictionaryArgument != null)
{
foreach (var kvp in args.DictionaryArgument.Arguments)
{
eval.DeclareVariable(kvp.Key, kvp.Value, VariableSource.Declaration, args.DictionaryArgument.Location);
}
}
}
private static void Assign(SequenceExpression seq, ValueEnumerator valueEnum, ExpressionEval eval)
{
foreach (var item in seq.Items)
{
switch (item)
{
case StarredExpression stx when stx.Expression is NameExpression nex && !string.IsNullOrEmpty(nex.Name):
eval.DeclareVariable(nex.Name, valueEnum.Next, VariableSource.Declaration, nex);
break;
case ParenthesisExpression pex when pex.Expression is NameExpression nex && !string.IsNullOrEmpty(nex.Name):
eval.DeclareVariable(nex.Name, valueEnum.Next, VariableSource.Declaration, nex);
break;
case NameExpression nex when !string.IsNullOrEmpty(nex.Name):
eval.DeclareVariable(nex.Name, valueEnum.Next, VariableSource.Declaration, nex);
break;
// Nested sequence expression in sequence, Tuple[Tuple[int, str], int], List[Tuple[int], str]
// TODO: Because of bug with how collection types are constructed, they don't make nested collection types
// into instances, meaning we have to create it here
case SequenceExpression se when valueEnum.Peek is IPythonCollection || valueEnum.Peek is IPythonCollectionType:
var collection = valueEnum.Next;
var pc = collection as IPythonCollection;
var pct = collection as IPythonCollectionType;
Assign(se, pc ?? pct.CreateInstance(ArgumentSet.Empty(se, eval)), eval);
break;
case SequenceExpression se:
Assign(se, valueEnum, eval);
break;
}
}
}
public override Task <bool> WalkAsync(ClassDefinition cd, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var classInfo = CreateClass(cd);
_eval.DeclareVariable(cd.Name, classInfo, GetLoc(cd));
_table.Add(new ClassEvaluator(_eval, cd));
// Open class scope
_scopes.Push(_eval.OpenScope(cd, out _));
return(Task.FromResult(true));
}
public override bool Walk(ClassDefinition cd)
{
if (!string.IsNullOrEmpty(cd.NameExpression?.Name))
{
var classInfo = CreateClass(cd);
_eval.DeclareVariable(cd.Name, classInfo, VariableSource.Declaration, GetLoc(cd));
_table.Add(new ClassEvaluator(_eval, cd));
// Open class scope
_scopes.Push(_eval.OpenScope(_eval.Module, cd, out _));
}
return(true);
}
private void TryReplaceMember(IVariable v, IPythonType sourceType, IPythonType stubType, CancellationToken cancellationToken)
{
// If type does not exist in module, but exists in stub, declare it unless it is an import.
// If types are the classes, take class from the stub, then add missing members.
// Otherwise, replace type by one from the stub.
switch (sourceType)
{
case null:
// Nothing in source, but there is type in the stub. Declare it.
if (v.Source == VariableSource.Declaration || v.Source == VariableSource.Generic)
{
_eval.DeclareVariable(v.Name, v.Value, v.Source);
}
break;
case IPythonClassType sourceClass:
MergeMembers(v, sourceClass, stubType, cancellationToken);
break;
case PythonFunctionType sourceFunction:
MergeMembers(v, sourceFunction, stubType, cancellationToken);
break;
case PythonPropertyType sourceProperty:
MergeMembers(v, sourceProperty, stubType, cancellationToken);
break;
case IPythonModule _:
// We do not re-declare modules.
break;
default:
var stubModule = stubType.DeclaringModule;
if (stubType is IPythonModule || stubModule.ModuleType == ModuleType.Builtins)
{
// Modules members that are modules should remain as they are, i.e. os.path
// should remain library with its own stub attached.
break;
}
// We do not re-declaring variables that are imported.
if (v.Source == VariableSource.Declaration)
{
TransferDocumentationAndLocation(sourceType, stubType);
// Re-declare variable with the data from the stub.
var source = _eval.CurrentScope.Variables[v.Name]?.Source ?? v.Source;
_eval.DeclareVariable(v.Name, v.Value, source);
}
break;
}
}
public override bool Walk(ClassDefinition cd)
{
if (!string.IsNullOrEmpty(cd.NameExpression?.Name))
{
var classInfo = CreateClass(cd);
// The variable is transient (non-user declared) hence it does not have location.
// Class type is tracking locations for references and renaming.
_eval.DeclareVariable(cd.Name, classInfo, VariableSource.Declaration);
_table.Add(new ClassEvaluator(_eval, cd));
// Open class scope
_scopes.Push(_eval.OpenScope(_eval.Module, cd, out _));
}
return(true);
}
private static void Assign(IEnumerable <Expression> items, ValueEnumerator valueEnum, ExpressionEval eval)
{
foreach (var item in items)
{
switch (item)
{
case StarredExpression stx when stx.Expression is NameExpression nex && !string.IsNullOrEmpty(nex.Name):
eval.DeclareVariable(nex.Name, valueEnum.Next, VariableSource.Declaration, nex);
break;
case NameExpression nex when !string.IsNullOrEmpty(nex.Name):
eval.DeclareVariable(nex.Name, valueEnum.Next, VariableSource.Declaration, nex);
break;
case TupleExpression te:
Assign(te.Items, valueEnum, eval);
break;
}
}
}
private static void AssignTuple(TupleExpression tex, ValueEnumerator valueEnum, ExpressionEval eval)
{
foreach (var item in tex.Items)
{
switch (item)
{
case NameExpression nex when !string.IsNullOrEmpty(nex.Name):
eval.DeclareVariable(nex.Name, valueEnum.Next, VariableSource.Declaration, nex);
break;
case TupleExpression te:
AssignTuple(te, valueEnum, eval);
break;
}
}
}
internal static void Assign(IEnumerable <Expression> lhs, TupleExpression rhs, ExpressionEval eval)
{
var names = NamesFromSequenceExpression(lhs).ToArray();
var values = ValuesFromSequenceExpression(rhs.Items, eval).ToArray();
for (var i = 0; i < names.Length; i++)
{
IMember value = null;
if (values.Length > 0)
{
value = i < values.Length ? values[i] : values[values.Length - 1];
}
if (!string.IsNullOrEmpty(names[i]?.Name))
{
eval.DeclareVariable(names[i].Name, value ?? eval.UnknownType, VariableSource.Declaration, names[i]);
}
}
}
internal static void AssignTuple(TupleExpression lhs, TupleExpression rhs, ExpressionEval eval)
{
var returnedExpressions = rhs.Items.ToArray();
var names = lhs.Items.OfType <NameExpression>().Select(x => x.Name).ToArray();
for (var i = 0; i < names.Length; i++)
{
Expression e = null;
if (returnedExpressions.Length > 0)
{
e = i < returnedExpressions.Length ? returnedExpressions[i] : returnedExpressions[returnedExpressions.Length - 1];
}
if (e != null && !string.IsNullOrEmpty(names[i]))
{
var v = eval.GetValueFromExpression(e);
eval.DeclareVariable(names[i], v ?? eval.UnknownType, VariableSource.Declaration, e);
}
}
}