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); }