public override void PostWalk(ClassDefinition node) {
if (node.Body != null && node.Name != null) {
Debug.Assert(_scope.Node == node);
Debug.Assert(_scope.OuterScope.Node != node);
_scope = _scope.OuterScope;
_curUnit = _analysisStack.Pop();
Debug.Assert(_scope.EnumerateTowardsGlobal.Contains(_curUnit.Scope));
}
}
public AstPythonType(PythonAst ast, IPythonModule declModule, ClassDefinition def, string doc, LocationInfo loc) {
_members = new Dictionary<string, IMember>();
Name = def.Name;
Documentation = doc;
DeclaringModule = declModule;
Mro = new IPythonType[0];
Locations = new[] { loc };
}
// TODO: What about names being redefined?
// remember classes/functions as they start new scopes
public override bool Walk(ClassDefinition node) {
var cls = AddClass(node, _curUnit);
if (cls != null) {
_analysisStack.Push(_curUnit);
_curUnit = cls.AnalysisUnit;
Debug.Assert(_scope.EnumerateTowardsGlobal.Contains(cls.AnalysisUnit.Scope.OuterScope));
_scope = cls.AnalysisUnit.Scope;
return true;
}
return false;
}
internal ClassInfo AddClass(ClassDefinition node, AnalysisUnit outerUnit) {
InterpreterScope scope;
var declScope = outerUnit.Scope;
if (!declScope.TryGetNodeScope(node, out scope)) {
if (node.Body == null || node.Name == null) {
return null;
}
var unit = new ClassAnalysisUnit(node, declScope, outerUnit);
var classScope = (ClassScope)unit.Scope;
var classVar = declScope.AddLocatedVariable(node.Name, node.NameExpression, unit);
classVar.AddTypes(unit, classScope.Class.SelfSet);
declScope.Children.Add(classScope);
declScope.AddNodeScope(node, classScope);
unit.Enqueue();
scope = classScope;
}
return scope.AnalysisValue as ClassInfo;
}
public override void PostWalk(ClassDefinition node) {
_scopes.RemoveAt(_scopes.Count - 1);
base.PostWalk(node);
}
public override bool Walk(ClassDefinition node) {
_names.Add(node.Name);
return base.Walk(node);
}
public override void PostWalk(ClassDefinition node) {
EndScope(true);
Debug.Assert(_head != null);
base.PostWalk(node);
}
// ClassDefinition
public override void PostWalk(ClassDefinition node) {
Debug.Assert(node == _currentScope);
PopScope();
}
public ClassScope(ClassInfo classInfo, ClassDefinition ast, InterpreterScope outerScope)
: base(classInfo, ast, outerScope) {
classInfo.Scope = this;
}
public override bool Walk(ClassDefinition node) {
_define.WalkName(node.NameExpression, node.GetVariableReference(_root));
bool oldInLoop = _inLoop;
_inLoop = false;
var res = base.Walk(node);
_inLoop = oldInLoop;
return res;
}
public override bool Walk(ClassDefinition node) {
return false;
}
public override bool Walk(ClassDefinition node) {
if (FunctionName == null) {
ClassName = node.Name;
}
return base.Walk(node);
}
// ClassDef
public override bool Walk(ClassDefinition node) {
if (_scope == node) {
// the class body is being analyzed, go deep:
return true;
} else {
// analyze the class definition itself (it is visited while analyzing parent scope):
Define(node.Name);
foreach (var e in node.Bases) {
e.Expression.Walk(this);
}
return false;
}
}
public override void PostWalk(ClassDefinition node) { PostWalkWorker(node); }
// ClassDefinition
public override bool Walk(ClassDefinition node) { return ShouldWalkWorker(node); }
public override bool Walk(ClassDefinition node) {
AddTagIfNecessary(node, node.HeaderIndex + 1, node.Decorators);
return base.Walk(node);
}
public override void PostWalk(ClassDefinition node) {
_scopes.Add(node);
base.PostWalk(node);
}
public override void PostWalk(ClassDefinition node) {
_scopes.Add(node);
_allWrites.Add(node.GetVariableReference(_root));
_allWrittenVariables.Add(node.Variable);
base.PostWalk(node);
}
public override bool Walk(ClassDefinition node) {
Classes.Add(WalkScope(node));
return false;
}
public ClassScopeNode(ClassDefinition klass) {
_klass = klass;
}
// ClassDefinition
public override bool Walk(ClassDefinition node) {
if (node.Name != null) {
node.Variable = DefineName(node.Name);
node.AddVariableReference(_globalScope, _bindRefs, Reference(node.Name));
}
if (node.Bases != null) {
// Base references are in the outer context
foreach (var b in node.Bases) b.Expression.Walk(this);
}
// process the decorators in the outer context
if (node.Decorators != null) {
foreach (Expression dec in node.Decorators.Decorators) {
if (dec != null) {
dec.Walk(this);
}
}
}
PushScope(node);
node.ModuleNameVariable = _globalScope.EnsureGlobalVariable("__name__");
// define the __doc__ and the __module__
if (node.Body.Documentation != null) {
node.DocVariable = DefineName("__doc__");
}
node.ModVariable = DefineName("__module__");
if (_langVersion.Is3x()) {
node.ClassVariable = DefineName("__class__");
}
// Walk the body
node.Body.Walk(this);
return false;
}
public override bool Walk(ClassDefinition node) {
var m = _scope.Peek();
if (m != null) {
var n = new Dictionary<string, IMember>();
AstPythonType t = new AstPythonType(_ast, _module, node, GetDoc(node.Body as SuiteStatement), GetLoc(node));
m[node.Name] = n["__class__"] = t;
_scope.Push(n);
return true;
}
return false;
}
public override bool Walk(ClassDefinition node) {
Debug.Assert(_head != null);
_head.Types.Add(node.NameExpression.Name);
node.NameExpression.Walk(this);
BeginScope(node.NameExpression.Name);
return base.Walk(node);
}
public override void PostWalk(ClassDefinition node) {
var cls = CurrentClass as AstPythonType;
var m = _scope.Pop();
if (cls != null && m != null) {
cls.AddMembers(m, true);
}
base.PostWalk(node);
}
//classdef: 'class' NAME ['(' testlist ')'] ':' suite
private Statement ParseClassDef() {
Eat(TokenKind.KeywordClass);
string classWhiteSpace = _tokenWhiteSpace;
var start = GetStart();
var name = ReadName();
var nameExpr = MakeName(name);
nameExpr.SetLoc(GetStart(), GetEnd());
string nameWhiteSpace = _tokenWhiteSpace;
if (name.RealName == null) {
// no name, assume there's no class.
return ErrorStmt(_verbatim ? (classWhiteSpace + "class") : null);
}
bool isParenFree = false;
string leftParenWhiteSpace = null, rightParenWhiteSpace = null;
List<string> commaWhiteSpace = null;
Arg[] args;
bool ateTerminator = true;
if (MaybeEat(TokenKind.LeftParenthesis)) {
leftParenWhiteSpace = _tokenWhiteSpace;
commaWhiteSpace = MakeWhiteSpaceList();
if (_langVersion.Is3x()) {
args = FinishArgumentList(null, commaWhiteSpace, out ateTerminator);
rightParenWhiteSpace = _tokenWhiteSpace;
} else {
bool trailingComma;
List<Expression> l = ParseTestListAsExpr(null, out commaWhiteSpace, out trailingComma);
if (l.Count == 1 && l[0] is ErrorExpression) {
// error handling, classes is incomplete.
return ErrorStmt(
_verbatim ? (classWhiteSpace + "class" + nameWhiteSpace + name.VerbatimName + leftParenWhiteSpace + "(" + ((ErrorExpression)l[0]).VerbatimImage) : null
);
}
args = new Arg[l.Count];
for (int i = 0; i < l.Count; i++) {
args[i] = new Arg(l[i]);
}
ateTerminator = Eat(TokenKind.RightParenthesis);
rightParenWhiteSpace = _tokenWhiteSpace;
}
} else {
isParenFree = true;
args = new Arg[0];
}
var mid = GetEnd();
// Save private prefix
string savedPrefix = SetPrivatePrefix(name.VerbatimName);
_classDepth++;
// Parse the class body
Statement body = ParseClassOrFuncBody();
_classDepth--;
// Restore the private prefix
_privatePrefix = savedPrefix;
ClassDefinition ret = new ClassDefinition(nameExpr, args, body);
AddVerbatimName(name, ret);
if (_verbatim) {
if (isParenFree) {
AddIsAltForm(ret);
}
AddPreceedingWhiteSpace(ret, classWhiteSpace);
AddSecondPreceedingWhiteSpace(ret, nameWhiteSpace);
if (leftParenWhiteSpace != null) {
AddThirdPreceedingWhiteSpace(ret, leftParenWhiteSpace);
}
if (rightParenWhiteSpace != null) {
AddFourthPreceedingWhiteSpace(ret, rightParenWhiteSpace);
}
if (commaWhiteSpace != null) {
AddListWhiteSpace(ret, commaWhiteSpace.ToArray());
}
if (!ateTerminator) {
AddErrorMissingCloseGrouping(ret);
}
}
ret.HeaderIndex = mid;
ret.SetLoc(start, body.EndIndex);
return ret;
}
private static void FillClassDescription(List<AP.DescriptionComponent> description, ClassDefinition classDef) {
description.Add(new AP.DescriptionComponent("class ", "misc"));
description.Add(new AP.DescriptionComponent(classDef.Name, "name"));
if (classDef.Bases.Count > 0) {
description.Add(new AP.DescriptionComponent("(", "misc"));
bool comma = false;
foreach (var baseClass in classDef.Bases) {
if (comma) {
description.Add(new AP.DescriptionComponent(", ", "misc"));
}
string baseStr = FormatExpression(baseClass.Expression);
if (baseStr != null) {
description.Add(new AP.DescriptionComponent(baseStr, "type"));
}
comma = true;
}
description.Add(new AP.DescriptionComponent(")", "misc"));
}
description.Add(new AP.DescriptionComponent("\n", "misc"));
description.Add(new AP.DescriptionComponent(null, "enddecl"));
if (!String.IsNullOrWhiteSpace(classDef.Body.Documentation)) {
description.Add(new AP.DescriptionComponent(" " + classDef.Body.Documentation, "misc"));
}
}
public override bool Walk(ClassDefinition node) {
CanComplete = false;
return base.Walk(node);
}
// ClassDefinition
public override void PostWalk(ClassDefinition node)
{
Debug.Assert(node == _currentScope);
PopScope();
}
