// FunctionDefinition
public bool Walk(IronPython.Compiler.Ast.FunctionDefinition node)
{
current = node; return Process(node);
}
private void AssertCurrent(ScopeStatement node)
{
Debug.Assert((object)node == (object)current);
}
// FunctionDefinition
public override void PostWalk(FunctionDefinition node) {
Debug.Assert(_currentScope == node);
_scopes.Add(_currentScope);
_currentScope = _currentScope.Parent;
}
public void PostWalk(IronPython.Compiler.Ast.FunctionDefinition node)
{
AssertCurrent(node); current = current.Parent;
}
private FlowChecker(ScopeStatement scope) {
_variables = scope.Variables;
_bits = new BitArray(_variables.Count * 2);
int index = 0;
foreach (var binding in _variables) {
binding.Value.Index = index++;
}
_scope = scope;
_fdef = new FlowDefiner(this);
_fdel = new FlowDeleter(this);
}
private void Bind(PythonAst unboundAst) {
Assert.NotNull(unboundAst);
_currentScope = _globalScope = unboundAst;
// Find all scopes and variables
unboundAst.Walk(this);
// Bind
foreach (ScopeStatement scope in _scopes) {
scope.Bind(this);
}
// Finish the globals
unboundAst.Bind(this);
// Run flow checker
foreach (ScopeStatement scope in _scopes) {
FlowChecker.Check(scope);
}
}
public void SetLoc(PythonAst globalParent, IndexSpan span)
{
_span = span;
_parent = globalParent;
}
private FlowChecker(ScopeStatement scope)
{
bindings = scope.Bindings;
bits = new BitArray(bindings.Count * 2);
int index = 0;
foreach (KeyValuePair<SymbolId, Binding> binding in bindings) {
binding.Value.Index = index++;
}
this.scope = scope;
this.fdef = new FlowDefiner(this);
this.fdel = new FlowDeleter(this);
}
public DelayedProfiling(ScopeStatement ast, MSAst.Expression body, MSAst.ParameterExpression tick)
{
_ast = ast;
_body = body;
_tick = tick;
}
public void SetLoc(PythonAst globalParent, int start, int end)
{
_span = new IndexSpan(start, end > start ? end - start : start);
_parent = globalParent;
}
internal virtual bool TryBindOuter(ScopeStatement from, PythonReference reference, out PythonVariable variable)
{
// Hide scope contents by default (only functions expose their locals)
variable = null;
return(false);
}
protected override MSAst.Expression VisitExtension(MSAst.Expression node)
{
if (node == _globalContext)
{
return(PythonAst._globalContext);
}
// we need to re-write nested scoeps
ScopeStatement scope = node as ScopeStatement;
if (scope != null)
{
return(base.VisitExtension(VisitScope(scope)));
}
LambdaExpression lambda = node as LambdaExpression;
if (lambda != null)
{
return(base.VisitExtension(new LambdaExpression((FunctionDefinition)VisitScope(lambda.Function))));
}
GeneratorExpression generator = node as GeneratorExpression;
if (generator != null)
{
return(base.VisitExtension(new GeneratorExpression((FunctionDefinition)VisitScope(generator.Function), generator.Iterable)));
}
// update the global get/set/raw gets variables
PythonGlobalVariableExpression global = node as PythonGlobalVariableExpression;
if (global != null)
{
return(new LookupGlobalVariable(
_curScope == null ? PythonAst._globalContext : _curScope.LocalContext,
global.Variable.Name,
global.Variable.Kind == VariableKind.Local
));
}
// set covers sets and deletes
var setGlobal = node as PythonSetGlobalVariableExpression;
if (setGlobal != null)
{
if (setGlobal.Value == PythonGlobalVariableExpression.Uninitialized)
{
return(new LookupGlobalVariable(
_curScope == null ? PythonAst._globalContext : _curScope.LocalContext,
setGlobal.Global.Variable.Name,
setGlobal.Global.Variable.Kind == VariableKind.Local
).Delete());
}
else
{
return(new LookupGlobalVariable(
_curScope == null ? PythonAst._globalContext : _curScope.LocalContext,
setGlobal.Global.Variable.Name,
setGlobal.Global.Variable.Kind == VariableKind.Local
).Assign(Visit(setGlobal.Value)));
}
}
var rawValue = node as PythonRawGlobalValueExpression;
if (rawValue != null)
{
return(new LookupGlobalVariable(
_curScope == null ? PythonAst._globalContext : _curScope.LocalContext,
rawValue.Global.Variable.Name,
rawValue.Global.Variable.Kind == VariableKind.Local
));
}
return(base.VisitExtension(node));
}
public LookupVisitor(PythonAst ast, MSAst.Expression globalContext)
{
_globalContext = globalContext;
_curScope = ast;
}
private void PopScope()
{
_scopes.Add(_currentScope);
_currentScope = _currentScope.Parent;
_finallyCount.RemoveAt(_finallyCount.Count - 1);
}
internal void UpdateReferencedVariables(string name, PythonVariable variable, ScopeStatement parent) {
if (variable.Kind == VariableKind.Global || variable.Kind == VariableKind.GlobalLocal) {
AddReferencedGlobal(name);
} else {
name = AddFreeVariable(name);
for (ScopeStatement innerParent = Parent; innerParent != parent; innerParent = innerParent.Parent) {
innerParent.AddFreeVariable(name);
}
}
}
/// <summary>
/// Gets the region of the scope statement (typically a ClassDefinition).
/// </summary>
/// <remarks>
/// A class region includes the body.
/// </remarks>
DomRegion GetRegion(ScopeStatement statement)
{
return new DomRegion(statement.Start.Line, statement.Start.Column, statement.End.Line, statement.End.Column);
}
public override void PostWalk(ClassDefinition node)
{
Debug.Assert(node == current);
current = current.Parent;
}
public static void Check(ScopeStatement scope)
{
FlowChecker fc = new FlowChecker(scope);
scope.Walk(fc);
}
public override void PostWalk(FunctionDefinition node)
{
Debug.Assert(current == node);
current = current.Parent;
}
public static void Check(ScopeStatement scope) {
if (scope.Variables != null) {
FlowChecker fc = new FlowChecker(scope);
scope.Walk(fc);
}
}
// GlobalSuite
public override void PostWalk(GlobalSuite node)
{
current = current.Parent;
}
private void PushScope(ScopeStatement node) {
node.Parent = _currentScope;
_currentScope = node;
}
// ClassDef
public override bool Walk(ClassDefinition node)
{
Define(node.Name);
// Base references are in the outer scope
foreach (Expression b in node.Bases) b.Walk(this);
// And so is the __name__ reference
Reference(SymbolTable.Name);
node.Parent = current;
current = node;
// define the __doc__ and the __module__
Define(SymbolTable.Doc);
Define(SymbolTable.Module);
// Walk the body
node.Body.Walk(this);
processed.Add(node);
return false;
}
// PythonAst
public override void PostWalk(PythonAst node) {
// Do not add the global suite to the list of processed nodes,
// the publishing must be done after the class local binding.
Debug.Assert(_currentScope == node);
_currentScope = _currentScope.Parent;
}
// FuncDef
public override bool Walk(FunctionDefinition node)
{
// Name is defined in the enclosing scope
Define(node.Name);
// process the default arg values in the outer scope
foreach (Expression e in node.Defaults) {
e.Walk(this);
}
// process the decorators in the outer scope
if (node.Decorators != null) {
node.Decorators.Walk(this);
}
node.Parent = current;
current = node;
foreach (Expression e in node.Parameters) {
e.Walk(parameter);
}
node.Body.Walk(this);
processed.Add(node);
return false;
}
public void PostWalk(GlobalSuite node)
{
AssertCurrent(node); current = current.Parent;
}
private GlobalSuite DoBind(Statement root)
{
GlobalSuite global = new GlobalSuite(root);
current = global;
// Detect all local names
root.Walk(this);
// Binding the free variables
foreach (ScopeStatement scope in processed) {
scope.BindNames(global, this);
}
// Validate
foreach (ScopeStatement scope in processed) {
if ((scope.ScopeInfo &
(ScopeStatement.ScopeAttributes.ContainsFreeVariables |
ScopeStatement.ScopeAttributes.ContainsImportStar |
ScopeStatement.ScopeAttributes.ContainsUnqualifiedExec |
ScopeStatement.ScopeAttributes.ContainsNestedFreeVariables)) == 0) {
continue;
}
FunctionDefinition func;
if ((func = scope as FunctionDefinition) != null) {
if (func.ContainsImportStar && func.IsClosure) {
ReportSyntaxError(String.Format("import * is not allowed in function '{0}' because it is a nested function", func.Name.GetString()), func);
}
if (func.ContainsImportStar && func.Parent is FunctionDefinition) {
ReportSyntaxError(String.Format("import * is not allowed in function '{0}' because it is a nested function", func.Name.GetString()), func);
}
if (func.ContainsImportStar && func.ContainsNestedFreeVariables) {
ReportSyntaxError(String.Format("import * is not allowed in function '{0}' because it contains a nested function with free variables", func.Name.GetString()), func);
}
if (func.ContainsUnqualifiedExec && func.ContainsNestedFreeVariables) {
ReportSyntaxError(String.Format("unqualified exec is not allowed in function '{0}' it contains a nested function with free variables", func.Name.GetString()), func);
}
if (func.ContainsUnqualifiedExec && func.IsClosure) {
ReportSyntaxError(String.Format("unqualified exec is not allowed in function '{0}' it is a nested function", func.Name.GetString()), func);
}
}
ClassDefinition cls;
if ((cls = scope as ClassDefinition) != null) {
if (cls.ContainsImportStar) {
// warning
}
}
}
return global;
}
// GlobalSuite
public bool Walk(GlobalSuite node)
{
current = node; return Process(node);
}
/// <summary>
/// Gets the region of the scope statement (ClassDefinition).
/// </summary>
/// <remarks>
/// A class region includes the body.
/// </remarks>
void GetRegion(ScopeStatement statement)
{
Region = new DomRegion(statement.Start.Line, statement.Start.Column, statement.End.Line, statement.End.Column);
}
private void SaveCandidate(Node node)
{
if (candidateNode == null || Better(node, candidateNode))
{
Debug.Print("Candidate: {0} at {1}:{2}-{3}:{4} ({5}:{6})",
node, node.Start.Line, node.Start.Column, node.End.Line, node.End.Column,
location.Line, location.Column);
candidateNode = node;
candidateScope = current;
candidateContext = context != null && context.Count > 0 ? context.Peek() : null;
}
}
private void PushScope(ScopeStatement node)
{
node.Parent = _currentScope;
_currentScope = node;
_finallyCount.Add(0);
}