private void HandleNameExpression(NameExpression ne, IMember value)
{
IScope scope;
if (Eval.CurrentScope.NonLocals[ne.Name] != null)
{
Eval.LookupNameInScopes(ne.Name, out scope, LookupOptions.Nonlocal);
scope?.Variables[ne.Name].Assign(value, Eval.GetLocationOfName(ne));
return;
}
if (Eval.CurrentScope.Globals[ne.Name] != null)
{
Eval.LookupNameInScopes(ne.Name, out scope, LookupOptions.Global);
scope?.Variables[ne.Name].Assign(value, Eval.GetLocationOfName(ne));
return;
}
var source = value.IsGeneric() ? VariableSource.Generic : VariableSource.Declaration;
var location = Eval.GetLocationOfName(ne);
if (IsValidAssignment(ne.Name, location))
{
Eval.DeclareVariable(ne.Name, value ?? Module.Interpreter.UnknownType, source, location);
}
}
private void TryAddBase(List <IPythonType> bases, Arg arg)
{
// We cheat slightly and treat base classes as annotations.
var b = Eval.GetTypeFromAnnotation(arg.Expression);
if (b != null)
{
var t = b.GetPythonType();
bases.Add(t);
t.AddReference(Eval.GetLocationOfName(arg.Expression));
}
}
public bool HandleGlobal(GlobalStatement node)
{
foreach (var nex in node.Names)
{
var m = Eval.LookupNameInScopes(nex.Name, out _, out var v, LookupOptions.Global);
if (m != null)
{
var location = Eval.GetLocationOfName(nex);
Eval.CurrentScope.DeclareGlobal(nex.Name, location);
v?.AddReference(location);
}
}
return(false);
}
public void EvaluateClass()
{
// Open class scope chain
using (Eval.OpenScope(Module, _classDef, out var outerScope)) {
var instance = Eval.GetInScope(_classDef.Name, outerScope);
if (!(instance?.GetPythonType() is PythonClassType classInfo))
{
if (instance != null)
{
// TODO: warning that variable is already declared of a different type.
}
return;
}
// Evaluate inner classes, if any
EvaluateInnerClasses(_classDef);
_class = classInfo;
// Set bases to the class.
var bases = new List <IPythonType>();
foreach (var a in _classDef.Bases.Where(a => string.IsNullOrEmpty(a.Name)))
{
// We cheat slightly and treat base classes as annotations.
var b = Eval.GetTypeFromAnnotation(a.Expression);
if (b != null)
{
var t = b.GetPythonType();
bases.Add(t);
t.AddReference(Eval.GetLocationOfName(a.Expression));
}
}
_class.SetBases(bases);
// Declare __class__ variable in the scope.
Eval.DeclareVariable("__class__", _class, VariableSource.Declaration);
ProcessClassBody();
}
}
public void HandleAssignment(AssignmentStatement node)
{
if (node.Right is ErrorExpression)
{
return;
}
var value = Eval.GetValueFromExpression(node.Right) ?? Eval.UnknownType;
// Check PEP hint first
var valueType = Eval.GetTypeFromPepHint(node.Right);
if (valueType != null)
{
HandleTypedVariable(valueType, value, node.Left.FirstOrDefault());
return;
}
if (value.IsUnknown())
{
Log?.Log(TraceEventType.Verbose, $"Undefined value: {node.Right.ToCodeString(Ast).Trim()}");
}
if (value?.GetPythonType().TypeId == BuiltinTypeId.Ellipsis)
{
value = Eval.UnknownType;
}
if (node.Left.FirstOrDefault() is SequenceExpression seq)
{
// Tuple = Tuple. Transfer values.
var seqHandler = new SequenceExpressionHandler(Walker);
seqHandler.HandleAssignment(seq.Items, node.Right, value);
return;
}
// Process annotations, if any.
foreach (var expr in node.Left.OfType <ExpressionWithAnnotation>())
{
// x: List[str] = [...]
HandleAnnotatedExpression(expr, value);
}
foreach (var ne in node.Left.OfType <NameExpression>())
{
if (Eval.CurrentScope.NonLocals[ne.Name] != null)
{
Eval.LookupNameInScopes(ne.Name, out var scope, LookupOptions.Nonlocal);
scope?.Variables[ne.Name].Assign(value, Eval.GetLocationOfName(ne));
continue;
}
if (Eval.CurrentScope.Globals[ne.Name] != null)
{
Eval.LookupNameInScopes(ne.Name, out var scope, LookupOptions.Global);
scope?.Variables[ne.Name].Assign(value, Eval.GetLocationOfName(ne));
continue;
}
var source = value.IsGeneric() ? VariableSource.Generic : VariableSource.Declaration;
var location = Eval.GetLocationOfName(ne);
if (IsValidAssignment(ne.Name, location))
{
Eval.DeclareVariable(ne.Name, value ?? Module.Interpreter.UnknownType, source, location);
}
}
TryHandleClassVariable(node, value);
}
private void TryHandleClassVariable(AssignmentStatement node, IMember value)
{
var mex = node.Left.OfType <MemberExpression>().FirstOrDefault();
if (!string.IsNullOrEmpty(mex?.Name) && mex.Target is NameExpression nex && nex.Name.EqualsOrdinal("self"))
{
var m = Eval.LookupNameInScopes(nex.Name, out _, LookupOptions.Local);
var cls = m.GetPythonType <IPythonClassType>();
if (cls != null)
{
using (Eval.OpenScope(Eval.Module, cls.ClassDefinition, out _)) {
Eval.DeclareVariable(mex.Name, value, VariableSource.Declaration, Eval.GetLocationOfName(mex));
}
}
}
}
private void TryHandleClassVariable(MemberExpression mex, IMember value)
{
if (mex.Target is NameExpression nex && nex.Name == "self")
{
var m = Eval.LookupNameInScopes(nex.Name, out _, LookupOptions.Local);
var cls = m.GetPythonType <IPythonClassType>();
if (cls != null)
{
using (Eval.OpenScope(Eval.Module, cls.ClassDefinition, out _)) {
Eval.DeclareVariable(mex.Name, value, VariableSource.Declaration, Eval.GetLocationOfName(mex));
}
}
}
}
