Inheritance: ScopeStatement
Esempio n. 1
0
        public override bool Walk(IronPython.Compiler.Ast.ClassDefinition node)
        {
            ClassNode classNode = new ClassNode(node);

            AddNode(classNode);
            return(true);
        }
		public override bool Walk(ClassDefinition node)
		{
			classDefinition = node;
			componentName = node.Name;
			node.Body.Walk(this);
			return false;
		}
 public override void PostWalk(IronPython.Compiler.Ast.ClassDefinition node)
 {
     Trace.TraceInformation("in method postWalk(ClassDefinition node)");
     m_currentParent = m_savedParents.Pop();
     Trace.TraceInformation("restored m_current parent to " + m_currentParent.Name);
     base.PostWalk(node);
 }
Esempio n. 4
0
		public override bool Walk(ClassDefinition classDefinition)
		{
			if (classDefinition.Parent != null) {
				PythonClass c = new PythonClass(compilationUnit, classDefinition);
				WalkClassBody(c, classDefinition.Body);
			}
			return false;
		}
Esempio n. 5
0
 public override void PostWalk(ClassDefinition node)
 {
     if (node.Body != null && node.Name != null) {
         _scopes.Pop();
         _scopeTree.Pop();
         _curUnit = _analysisStack.Pop();
     }
 }
Esempio n. 6
0
		public PythonClass(ICompilationUnit compilationUnit, ClassDefinition classDefinition)
			: base(compilationUnit, String.Empty)
		{
			GetFullyQualifiedName(classDefinition);
			GetClassRegions(classDefinition);
			AddBaseTypes(classDefinition.Bases);
			
			compilationUnit.Classes.Add(this);
		}
Esempio n. 7
0
        public void Visit(PyAst.ClassDefinition node)
        {
            WriteDecorators(node.Decorators ?? Array.Empty <PyAst.Expression>());
            var basesPart = node.Bases.Any() ? $"({VisitExpressionsList(node.Bases)})" : "";

            AppendLineWithIndentation($"class {node.Name}{basesPart}:");
            using (new Indenter(this)) {
                Visit(node.Body);
            }
        }
        /// <summary>
        /// This function overrides the behavior when the current node being walked is a ClassDefinition
        /// </summary>
        /// <param name="node"> the ClassDefinition node</param>
        /// <returns> boolean value. not important for this implementation. it is handeled by a call to the base Walk() method.</returns>
        public override bool Walk(IronPython.Compiler.Ast.ClassDefinition node)
        {
            UserDefinedType udt = PythonEntityCreationHelper.createClassUDT(node, m_currentCodeFile, m_currentParent);

            m_currentParent.AddChild(udt);
            udt.Parent = m_currentParent;
            m_savedParents.Push(m_currentParent);
            m_currentParent = udt;

            return(true);
        }
		/// <summary>
		/// Gets the fully qualified name of the base class.
		/// </summary>
		public static string GetBaseClassName(ClassDefinition classDefinition)
		{
			if (classDefinition.Bases.Count > 0) {
				Expression baseClassExpression = classDefinition.Bases[0];
				NameExpression nameExpression = baseClassExpression as NameExpression;
				MemberExpression memberExpression = baseClassExpression as MemberExpression;
				if (nameExpression != null) {
					return nameExpression.Name;
				}
				return PythonControlFieldExpression.GetMemberName(memberExpression);
			}
			return String.Empty;
		}
Esempio n. 10
0
		/// <summary>
		/// Walks a class definition.
		/// </summary>
		public override bool Walk(ClassDefinition node)
		{
			DefaultClass c = new DefaultClass(compilationUnit, GetFullyQualifiedClassName(node));
			c.Region = GetRegion(node);
			c.BodyRegion = GetBodyRegion(node.Body, node.Header);
			AddBaseTypes(c, node.Bases);
			
			// Save the class.
			compilationUnit.Classes.Add(c);
			
			// Walk through all the class items.
			currentClass = c;
			node.Body.Walk(this);
			currentClass = null;
			
			return false;
		}
        // ClassDefinition
        public override bool Walk(IronPython.Compiler.Ast.ClassDefinition node)
        {
            Define(node.Name, new ClassDefinition(node));

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

            PushScope(node);

            // define the __doc__
            SymbolId doc = SymbolTable.Doc;

            Define(doc, new DirectDefinition(typeof(string)));

            // Walk the body
            node.Body.Walk(this);
            return(false);
        }
 public ClassNode(IronPython.Compiler.Ast.ClassDefinition cls)
 {
     this.cls = cls;
 }
		void CreateClassWithNullBody()
		{
			ClassDefinition classDef = new ClassDefinition("classWithNoBody", null, null);
		}
Esempio n. 14
0
        /// <summary>
        /// This helper function creates a UDT of udtTypes.class
        /// </summary>
        /// <param name="node"> The ClassDefinition node to create the class UDT</param>
        /// <param name="currentCodeFile">The CodeFile</param>
        /// <param name="parent">the parent</param>
        /// <returns>the UDT from the ClassDefinition node</returns>
        internal static UserDefinedType createClassUDT(IronPython.Compiler.Ast.ClassDefinition node, CodeFile currentCodeFile, ISyntaxEntity parent)
        {
            UserDefinedType classObject = new Entities.UDT.ClassDefinition(node.Name, new FileSpan(node.Start.Line, node.Start.Column, node.End.Line, node.End.Column), parent, currentCodeFile);

            return(classObject);
        }
Esempio n. 15
0
 public override bool Walk(ClassDefinition node)
 {
     CheckForIllegalWords(node, node.Name);
     CommonWalk(node);
     return true;
 }
Esempio n. 16
0
 // ClassDefinition
 public bool Walk(IronPython.Compiler.Ast.ClassDefinition node)
 {
     current = node; return(Process(node));
 }
		public static DomRegion GetBodyRegion(ClassDefinition classDefinition)
		{
			return GetBodyRegion(classDefinition.Body, classDefinition.Header);
		}
Esempio n. 18
0
 private List <Inferred> InferClassDef(IronPython.Compiler.Ast.ClassDefinition node, Scope scope)
 {
     return(Engine.MakeList <Inferred>(module.GetClass(node)));
 }
Esempio n. 19
0
 public ClassDefinition(IronPython.Compiler.Ast.ClassDefinition @class)
 {
     this.@class = @class;
 }
Esempio n. 20
0
 internal ClassDef(ClassDefinition def)
     : this()
 {
     _name = def.Name;
     _bases = PythonOps.MakeEmptyList(def.Bases.Count);
     foreach (AstExpression expr in def.Bases)
         _bases.Add(Convert(expr));
     _body = ConvertStatements(def.Body);
     if (def.Decorators != null) {
         _decorator_list = PythonOps.MakeEmptyList(def.Decorators.Count);
         foreach (AstExpression expr in def.Decorators)
             _decorator_list.Add(Convert(expr));
     } else
         _decorator_list = PythonOps.MakeEmptyList(0);
 }
 public override void PostWalk(ClassDefinition node)
 {
     containers.Pop ();
 }
 public ClassDefinition(IronPython.Compiler.Ast.ClassDefinition @class)
 {
     this.@class = @class;
 }
        public override bool Walk(ClassDefinition node)
        {
            var klass = new PythonClass () {
                Name = node.Name,
                Region = GetDomRegion (node),
                Documentation = node.Documentation
            };

            containers.Peek ().Classes.Add (klass);
            containers.Push (klass);

            return base.Walk (node);
        }
Esempio n. 24
0
 // ClassDefinition
 public override void PostWalk(ClassDefinition node)
 {
     Debug.Assert(node == _currentScope);
     PopScope();
 }
Esempio n. 25
0
		/// <summary>
		/// Adds the namespace to the class name taken from the class definition.
		/// </summary>
		string GetFullyQualifiedClassName(ClassDefinition classDef)
		{
			return String.Concat(compilationUnit.UsingScope.NamespaceName, ".", classDef.Name);
		}
Esempio n. 26
0
 public ClassScope(Module module, Scope parent, IronPython.Compiler.Ast.ClassDefinition statement)
     : base(module, parent)
 {
     this.statement = statement;
 }
Esempio n. 27
0
 public override void PostWalk(IronPython.Compiler.Ast.ClassDefinition node)
 {
     scopes.Pop();
 }
Esempio n. 28
0
 // ClassDefinition
 public override void PostWalk(ClassDefinition node) {
     Debug.Assert(node == _currentScope);
     _scopes.Add(_currentScope);
     _currentScope = _currentScope.Parent;
 }
Esempio n. 29
0
 public ClassNode(IronPython.Compiler.Ast.ClassDefinition cls)
 {
     this.cls = cls;
 }
Esempio n. 30
0
 public ClassScopeNode(ClassDefinition klass)
 {
     _klass = klass;
 }
Esempio n. 31
0
 public ClassScope(Module module, Scope parent, IronPython.Compiler.Ast.ClassDefinition statement)
     : base(module, parent)
 {
     this.statement = statement;
 }
Esempio n. 32
0
 internal override Statement Revert()
 {
     ClassDefinition cd = new ClassDefinition(name, expr.RevertExprs(bases), RevertStmts(body));
     if (decorator_list.Count != 0)
         cd.Decorators = expr.RevertExprs(decorator_list);
     return cd;
 }
 private void PushScope(IronPython.Compiler.Ast.ClassDefinition cls)
 {
     PushScope(new ClassScope(module, current, cls));
 }
Esempio n. 34
0
        /// <summary>
        /// Creates the LambdaExpression which implements the body of the function.
        ///
        /// The functions signature is either "object Function(PythonFunction, ...)"
        /// where there is one object parameter for each user defined parameter or
        /// object Function(PythonFunction, object[]) for functions which take more
        /// than PythonCallTargets.MaxArgs arguments.
        /// </summary>
        private LightLambdaExpression CreateFunctionLambda()
        {
            bool needsWrapperMethod = _parameters.Length > PythonCallTargets.MaxArgs;
            Type delegateType       = GetDelegateType(_parameters, needsWrapperMethod, out _);

            MSAst.ParameterExpression localContext = null;
            ReadOnlyCollectionBuilder <MSAst.ParameterExpression> locals = new ReadOnlyCollectionBuilder <MSAst.ParameterExpression>();

            if (NeedsLocalContext)
            {
                localContext = LocalCodeContextVariable;
                locals.Add(localContext);
            }

            MSAst.ParameterExpression[] parameters = CreateParameters(needsWrapperMethod, locals);

            List <MSAst.Expression> init = new List <MSAst.Expression>();

            foreach (var param in _parameters)
            {
                if (GetVariableExpression(param.PythonVariable) is IPythonVariableExpression pyVar)
                {
                    var varInit = pyVar.Create();
                    if (varInit != null)
                    {
                        init.Add(varInit);
                    }
                }
            }

            // Transform the parameters.
            init.Add(Ast.ClearDebugInfo(GlobalParent.Document));

            locals.Add(PythonAst._globalContext);
            init.Add(Ast.Assign(PythonAst._globalContext, new GetGlobalContextExpression(_parentContext)));

            GlobalParent.PrepareScope(locals, init);

            // Create variables and references. Since references refer to
            // parameters, do this after parameters have been created.

            CreateFunctionVariables(locals, init);

            // If the __class__ variable is used in a class method then we need to initialize it.
            // This must be done before parameter initialization (in case one of the parameters is called __class__).
            ClassDefinition parent = FindParentOfType <ClassDefinition>();

            if (parent != null && TryGetVariable("__class__", out PythonVariable pVar))
            {
                init.Add(
                    AssignValue(
                        GetVariableExpression(pVar),
                        Ast.Call(AstMethods.LookupName, parent.Parent.LocalContext, Ast.Constant(parent.Name))
                        )
                    );
            }

            // Initialize parameters - unpack tuples.
            // Since tuples unpack into locals, this must be done after locals have been created.
            InitializeParameters(init, needsWrapperMethod, parameters);

            List <MSAst.Expression> statements = new List <MSAst.Expression>();
            // add beginning sequence point
            var start = GlobalParent.IndexToLocation(StartIndex);

            statements.Add(GlobalParent.AddDebugInfo(
                               AstUtils.Empty(),
                               new SourceSpan(new SourceLocation(0, start.Line, start.Column), new SourceLocation(0, start.Line, int.MaxValue))));


            // For generators, we need to do a check before the first statement for Generator.Throw() / Generator.Close().
            // The exception traceback needs to come from the generator's method body, and so we must do the check and throw
            // from inside the generator.
            if (IsGenerator)
            {
                MSAst.Expression s1 = YieldExpression.CreateCheckThrowExpression(SourceSpan.None);
                statements.Add(s1);
            }

            if (Body.CanThrow && !(Body is SuiteStatement) && Body.StartIndex != -1)
            {
                statements.Add(UpdateLineNumber(GlobalParent.IndexToLocation(Body.StartIndex).Line));
            }

            statements.Add(Body);
            MSAst.Expression body = Ast.Block(statements);

            if (Body.CanThrow && GlobalParent.PyContext.PythonOptions.Frames)
            {
                body = AddFrame(LocalContext, Ast.Property(_functionParam, typeof(PythonFunction).GetProperty(nameof(PythonFunction.__code__))), body);
                locals.Add(FunctionStackVariable);
            }

            body = AddProfiling(body);
            body = WrapScopeStatements(body, Body.CanThrow);
            body = Ast.Block(body, AstUtils.Empty());
            body = AddReturnTarget(body);

            MSAst.Expression bodyStmt = body;
            if (localContext != null)
            {
                var createLocal = CreateLocalContext(_parentContext);

                init.Add(
                    Ast.Assign(
                        localContext,
                        createLocal
                        )
                    );
            }

            init.Add(bodyStmt);

            bodyStmt = Ast.Block(init);

            // wrap a scope if needed
            bodyStmt = Ast.Block(locals.ToReadOnlyCollection(), bodyStmt);

            return(AstUtils.LightLambda(
                       typeof(object),
                       delegateType,
                       AddDefaultReturn(bodyStmt, typeof(object)),
                       Name + "$" + Interlocked.Increment(ref _lambdaId),
                       parameters
                       ));
        }
Esempio n. 35
0
 public InferredClass GetClass(IronPython.Compiler.Ast.ClassDefinition cls)
 {
     Debug.Assert(scopes.ContainsKey(cls));
     return(new InferredClass(scopes[cls] as ClassScope));
 }
Esempio n. 36
0
        //classdef: 'class' NAME ['(' testlist ')'] ':' suite
        private ClassDefinition ParseClassDef() {
            Eat(TokenKind.KeywordClass);
            
            SourceLocation start = GetStart();
            SymbolId name = ReadName();
            if (name == SymbolId.Empty) {
                // no name, assume there's no class.
                return new ClassDefinition(SymbolId.Empty, new Expression[0], new ExpressionStatement(new ErrorExpression()));
            }

            Expression[] bases = new Expression[0];
            if (MaybeEat(TokenKind.LeftParenthesis)) {
                List<Expression> l = ParseTestList();
                
                if (l.Count == 1 && l[0] is ErrorExpression) {
                    // error handling, classes is incomplete.
                    return new ClassDefinition(name, new Expression[0], new ExpressionStatement(new ErrorExpression()));
                }
                bases = l.ToArray();
                Eat(TokenKind.RightParenthesis);
            }
            SourceLocation mid = GetEnd();

            // Save private prefix
            string savedPrefix = SetPrivatePrefix(name);

            // Parse the class body
            Statement body = ParseSuite();

            // Restore the private prefix
            _privatePrefix = savedPrefix;

            ClassDefinition ret = new ClassDefinition(name, bases, body);
            ret.Header = mid;
            ret.SetLoc(start, GetEnd());
            return ret;
        }
Esempio n. 37
0
        // ClassDefinition
        public override bool Walk(ClassDefinition node)
        {
            node.PythonVariable = DefineName(node.Name);

            // Base references are in the outer context
            foreach (Expression b in node.Bases) b.Walk(this);

            // process the decorators in the outer context
            if (node.Decorators != null) {
                foreach (Expression dec in node.Decorators) {
                    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__");

            // Walk the body
            node.Body.Walk(this);
            return false;
        }
Esempio n. 38
0
        public override void PostWalk(ClassDefinition node)
        {
            SuiteStatement body = node.Body as SuiteStatement;

            int count = body == null
                ? 1
                : body.Statements.Count;

            var methods = body != null
                ? body.Statements
                    .OfType<FunctionDefinition>()
                    .ToList()
                : new List<FunctionDefinition>();

            var mDic = methods.ToDictionary(
                k => (Statement)k,
                v => -1
            );

            FunctionDefinition constructor = methods
                .FirstOrDefault(n => n.Name == "__init__");

            FunctionDefinition toString = methods
                .FirstOrDefault(n => n.Name == "__str__");

            List<string> statements = new List<string>();
            for (int i = count - 1; i >= 0; i--)
            {
                string st = Content();
                if (!String.IsNullOrWhiteSpace(st))
                {
                    if (body != null && body.Statements[i] is FunctionDefinition)
                    {
                        mDic[body.Statements[i]] = i;
                    }

                    statements.Add(st);
                }
            }
            statements.Reverse();

            StringBuilder sb = new StringBuilder();

            string[] constructorArgs = constructor != null
                ? constructor.Parameters
                    .Skip(1)
                    .Select(p => p.Name)
                    .ToArray()
                : new string[0];

            string factoryName = String.Format("{0}Class", node.Name);
            sb.AppendFormat("{0} = function({2}) {{ return new {1}({2}); }};", node.Name, factoryName, String.Join(", ", constructorArgs));
            sb.AppendLine();

            if (constructor != null)
            {
                sb.AppendFormat("{0} = {1}", factoryName, statements[mDic[constructor]]);
            }
            else
            {
                sb.AppendFormat("{0} = function() {{ }};", factoryName);
            }
            sb.AppendLine();

            for (int i = 0; i < statements.Count; i++)
            {
                if (mDic.Values.Contains(i))
                {
                    continue;
                }

                sb.AppendFormat("{0}.prototype.{1}", factoryName, statements[i]);
                sb.AppendLine();
                sb.AppendLine();
            }

            if (toString != null)
            {
                sb.AppendFormat("{0}.prototype.toString = {1}", factoryName, statements[mDic[toString]]);
                sb.AppendLine();
            }

            methods.Remove(constructor);
            methods.Remove(toString);

            foreach (var m in methods)
            {
                sb.AppendFormat("{0}.prototype.{1} = {2}", factoryName, m.Name, statements[mDic[m]]);
                sb.AppendLine();
            }

            Content(sb.ToString());

            CommonPostWalk(node, true);
        }
Esempio n. 39
0
        //classdef: 'class' NAME ['(' testlist ')'] ':' suite
        private ClassDefinition ParseClassDef() {
            Eat(TokenKind.KeywordClass);

            var start = GetStart();
            string name = ReadName();
            if (name == null) {
                // no name, assume there's no class.
                return new ClassDefinition(null, new Expression[0], ErrorStmt());
            }

            Expression[] bases = new Expression[0];
            if (MaybeEat(TokenKind.LeftParenthesis)) {
                List<Expression> l = ParseTestList();

                if (l.Count == 1 && l[0] is ErrorExpression) {
                    // error handling, classes is incomplete.
                    return new ClassDefinition(name, new Expression[0], ErrorStmt());
                }
                bases = l.ToArray();
                Eat(TokenKind.RightParenthesis);
            }
            var mid = GetEnd();

            // Save private prefix
            string savedPrefix = SetPrivatePrefix(name);

            // Parse the class body
            Statement body = ParseClassOrFuncBody();

            // Restore the private prefix
            _privatePrefix = savedPrefix;

            ClassDefinition ret = new ClassDefinition(name, bases, body);
            ret.HeaderIndex =  mid;
            ret.SetLoc(_globalParent, start, GetEnd());
            return ret;
        }
Esempio n. 40
0
 public void PostWalk(IronPython.Compiler.Ast.ClassDefinition node)
 {
     AssertCurrent(node); current = current.Parent;
 }
Esempio n. 41
0
        /// <summary>
        /// Creates the LambdaExpression which implements the body of the function.
        ///
        /// The functions signature is either "object Function(PythonFunction, ...)"
        /// where there is one object parameter for each user defined parameter or
        /// object Function(PythonFunction, object[]) for functions which take more
        /// than PythonCallTargets.MaxArgs arguments.
        /// </summary>
        private LightLambdaExpression CreateFunctionLambda()
        {
            bool     needsWrapperMethod = _parameters.Length > PythonCallTargets.MaxArgs;
            Delegate originalDelegate;
            Type     delegateType = GetDelegateType(_parameters, needsWrapperMethod, out originalDelegate);

            MSAst.ParameterExpression localContext = null;
            ReadOnlyCollectionBuilder <MSAst.ParameterExpression> locals = new ReadOnlyCollectionBuilder <MSAst.ParameterExpression>();

            if (NeedsLocalContext)
            {
                localContext = LocalCodeContextVariable;
                locals.Add(localContext);
            }

            MSAst.ParameterExpression[] parameters = CreateParameters(needsWrapperMethod, locals);

            List <MSAst.Expression> init = new List <MSAst.Expression>();

            foreach (var param in _parameters)
            {
                IPythonVariableExpression pyVar = GetVariableExpression(param.PythonVariable) as IPythonVariableExpression;
                if (pyVar != null)
                {
                    var varInit = pyVar.Create();
                    if (varInit != null)
                    {
                        init.Add(varInit);
                    }
                }
            }

            // Transform the parameters.
            init.Add(Ast.ClearDebugInfo(GlobalParent.Document));

            locals.Add(PythonAst._globalContext);
            init.Add(Ast.Assign(PythonAst._globalContext, new GetGlobalContextExpression(_parentContext)));

            GlobalParent.PrepareScope(locals, init);

            // Create variables and references. Since references refer to
            // parameters, do this after parameters have been created.

            CreateFunctionVariables(locals, init);

            // If the __class__ variable is used the a class method then we need to initialize it.
            // This must be done before parameter initialization (in case one of the parameters is called __class__).
            ClassDefinition parent = FindParentOfType <ClassDefinition>();
            PythonVariable  pVar;

            if (parent != null && TryGetVariable("__class__", out pVar))
            {
                init.Add(
                    AssignValue(
                        GetVariableExpression(pVar),
                        Ast.Call(AstMethods.LookupName, parent.Parent.LocalContext, Ast.Constant(parent.Name))
                        )
                    );
            }

            // Initialize parameters - unpack tuples.
            // Since tuples unpack into locals, this must be done after locals have been created.
            InitializeParameters(init, needsWrapperMethod, parameters);

            List <MSAst.Expression> statements = new List <MSAst.Expression>();
            // add beginning sequence point
            var start = GlobalParent.IndexToLocation(StartIndex);

            statements.Add(GlobalParent.AddDebugInfo(
                               AstUtils.Empty(),
                               new SourceSpan(new SourceLocation(0, start.Line, start.Column), new SourceLocation(0, start.Line, Int32.MaxValue))));


            // For generators, we need to do a check before the first statement for Generator.Throw() / Generator.Close().
            // The exception traceback needs to come from the generator's method body, and so we must do the check and throw
            // from inside the generator.
            if (IsGenerator)
            {
                MSAst.Expression s1 = YieldExpression.CreateCheckThrowExpression(SourceSpan.None);
                statements.Add(s1);
            }

            MSAst.ParameterExpression extracted = null;
            if (!IsGenerator && _canSetSysExcInfo)
            {
                // need to allocate the exception here so we don't share w/ exceptions made & freed
                // during the body.
                extracted = Ast.Parameter(typeof(Exception), "$ex");
                locals.Add(extracted);
            }

            if (_body.CanThrow && !(_body is SuiteStatement) && _body.StartIndex != -1)
            {
                statements.Add(UpdateLineNumber(GlobalParent.IndexToLocation(_body.StartIndex).Line));
            }

            statements.Add(Body);
            MSAst.Expression body = Ast.Block(statements);

            // If this function can modify sys.exc_info() (_canSetSysExcInfo), then it must restore the result on finish.
            //
            // Wrap in
            //   $temp = PythonOps.SaveCurrentException()
            //   <body>
            //   PythonOps.RestoreCurrentException($temp)
            // Skip this if we're a generator. For generators, the try finally is handled by the PythonGenerator class
            //  before it's invoked. This is because the restoration must occur at every place the function returns from
            //  a yield point. That's different than the finally semantics in a generator.
            if (extracted != null)
            {
                MSAst.Expression s = AstUtils.Try(
                    Ast.Assign(
                        extracted,
                        Ast.Call(AstMethods.SaveCurrentException)
                        ),
                    body
                    ).Finally(
                    Ast.Call(
                        AstMethods.RestoreCurrentException, extracted
                        )
                    );
                body = s;
            }

            if (_body.CanThrow && GlobalParent.PyContext.PythonOptions.Frames)
            {
                body = AddFrame(LocalContext, Ast.Property(_functionParam, typeof(PythonFunction).GetProperty("__code__")), body);
                locals.Add(FunctionStackVariable);
            }

            body = AddProfiling(body);
            body = WrapScopeStatements(body, _body.CanThrow);
            body = Ast.Block(body, AstUtils.Empty());
            body = AddReturnTarget(body);


            MSAst.Expression bodyStmt = body;
            if (localContext != null)
            {
                var createLocal = CreateLocalContext(_parentContext);

                init.Add(
                    Ast.Assign(
                        localContext,
                        createLocal
                        )
                    );
            }

            init.Add(bodyStmt);

            bodyStmt = Ast.Block(init);

            // wrap a scope if needed
            bodyStmt = Ast.Block(locals.ToReadOnlyCollection(), bodyStmt);

            return(AstUtils.LightLambda(
                       typeof(object),
                       delegateType,
                       AddDefaultReturn(bodyStmt, typeof(object)),
                       Name + "$" + Interlocked.Increment(ref _lambdaId),
                       parameters
                       ));
        }
Esempio n. 42
0
 // Don't recurse into class or function definitions
 public override bool Walk(ClassDefinition node)
 {
     return(false);
 }
Esempio n. 43
0
 // 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 (Expression e in node.Bases) {
             e.Walk(this);
         }
         return false;
     }
 }
Esempio n. 44
0
 // ClassDefinition
 public override void PostWalk(ClassDefinition node)
 {
     Debug.Assert(node == _currentScope);
     PopScope();
 }
 public override bool Walk(ClassDefinition node)
 {
     // Do not recurse into nested classes
     return false;
 }
Esempio n. 46
0
 internal ClassDef(ClassDefinition def)
     : this() {
     _name = def.Name;
     _bases = PythonOps.MakeEmptyList(def.Bases.Count);
     foreach (Compiler.Ast.Expression expr in def.Bases)
         _bases.Add(Convert(expr));
     _body = ConvertStatements(def.Body);
     _decorator_list = new PythonList(); // TODO Actually fill in the decorators here
 }
Esempio n. 47
0
        // TODO: What about names being redefined?
        // remember classes/functions as they start new scopes
        public override bool Walk(ClassDefinition node)
        {
            if (node.Body == null || node.Name == null) {
                return false;
            }

            var queue = _entry.ProjectState.Queue;

            var scopes = new InterpreterScope[_scopes.Count + 1];
            _scopes.CopyTo(scopes);

            _analysisStack.Push(_curUnit);
            var unit = _curUnit = new AnalysisUnit(node, scopes, _curUnit);
            var klass = new ClassInfo(unit, _entry);
            var classScope = klass.Scope;

            var scope = _scopes.Peek();
            scope.SetVariable(node, unit, node.Name, klass.SelfSet);

            _scopes.Push(classScope);
            scopes[scopes.Length - 1] = classScope;

            // TODO: Add parameters for __new__/__init__
            PushPositionScope(node, classScope);

            return true;
        }
Esempio n. 48
0
 // Don't recurse into class or function definitions
 public override bool Walk(ClassDefinition node) {
     return false;
 }
Esempio n. 49
0
 // ClassDef
 public override bool Walk(ClassDefinition node)
 {
     if (scope == node) {
         return true;
     } else {
         Define(node.Name);
         return false;
     }
 }