public Expression ToExpression() { // // We can't emit a real filter or fault because they don't // work in DynamicMethods. Instead we do a simple transformation: // fault -> catch (Exception) { ...; rethrow } // filter -> catch (ExceptionType) { if (!filter) rethrow; ... } // // Note that the filter transformation is not quite equivalent to // real CLR semantics, but it's what IronPython and IronRuby // expect. If we get CLR support we'll switch over to real filter // and fault blocks. // var handlers = new List <CatchBlock>(_catchBlocks); for (int i = 0, n = handlers.Count; i < n; i++) { CatchBlock handler = handlers[i]; if (handler.Filter != null) { handlers[i] = Expression.MakeCatchBlock( handler.Test, handler.Variable, Expression.Condition( handler.Filter, handler.Body, Expression.Rethrow(handler.Body.Type) ), null ); } } if (_fault != null) { ContractUtils.Requires(handlers.Count == 0, "fault cannot be used with catch or finally clauses"); handlers.Add(Expression.Catch(typeof(Exception), Expression.Block(_fault, Expression.Rethrow(_try.Type)))); } var result = Expression.MakeTry(null, _try, _finally, null, handlers); if (_enableJumpsFromFinally) { return(Utils.FinallyFlowControl(result)); } return(result); }
private CatchBlock[] VisitHandlers(TryExpression node, bool realCatch) { CatchBlock[] handlers = new CatchBlock[node.Handlers.Count]; for (int i = 0; i < node.Handlers.Count; i++) { var handler = node.Handlers[i]; ParameterExpression oldRethrow = _rethrow; try { if (handler.Variable == null) { ParameterExpression rethrow = _rethrow = Expression.Parameter(handler.Test, "$exception"); handlers[i] = Expression.Catch( rethrow, TrackCatch(Visit(handler.Body), rethrow, realCatch), Visit(handler.Filter) ); } else { ParameterExpression rethrow = _rethrow = Expression.Parameter(typeof(Exception), "$exception"); handlers[i] = Expression.Catch( handler.Variable, Expression.Block( new[] { rethrow }, Expression.Assign(rethrow, handler.Variable), TrackCatch(Visit(handler.Body), rethrow, realCatch) ), Visit(handler.Filter) ); } } finally { _rethrow = oldRethrow; } } return(handlers); }
protected override Expression VisitTry(TryExpression node) { int startYields = _yields.Count; bool savedInTryWithFinally = _inTryWithFinally; if (node.Finally != null || node.Fault != null) { _inTryWithFinally = true; } Expression @try = Visit(node.Body); int tryYields = _yields.Count; IList <CatchBlock> handlers = Visit(node.Handlers, VisitCatchBlock); int catchYields = _yields.Count; // push a new return label in case the finally block yields _returnLabels.Push(Expression.Label()); // only one of these can be non-null Expression @finally = Visit(node.Finally); Expression fault = Visit(node.Fault); LabelTarget finallyReturn = _returnLabels.Pop(); int finallyYields = _yields.Count; _inTryWithFinally = savedInTryWithFinally; if (@try == node.Body && handlers == node.Handlers && @finally == node.Finally && fault == node.Fault) { return(node); } // No yields, just return if (startYields == _yields.Count) { return(Expression.MakeTry(null, @try, @finally, fault, handlers)); } if (fault != null && finallyYields != catchYields) { // No one needs this yet, and it's not clear how we should get back to // the fault throw new NotSupportedException("yield in fault block is not supported"); } // If try has yields, we need to build a new try body that // dispatches to the yield labels var tryStart = Expression.Label(); if (tryYields != startYields) { @try = Expression.Block(MakeYieldRouter(node.Body.Type, startYields, tryYields, tryStart), @try); } // Transform catches with yield to deferred handlers if (catchYields != tryYields) { var block = new List <Expression>(); block.Add(MakeYieldRouter(node.Body.Type, tryYields, catchYields, tryStart)); block.Add(null); // empty slot to fill in later for (int i = 0, n = handlers.Count; i < n; i++) { CatchBlock c = handlers[i]; if (c == node.Handlers[i]) { continue; } if (handlers.IsReadOnly) { handlers = handlers.ToArray(); } // the variable that will be scoped to the catch block var exceptionVar = Expression.Variable(c.Test, null); // the variable that the catch block body will use to // access the exception. We reuse the original variable if // the catch block had one. It needs to be hoisted because // the catch might contain yields. var deferredVar = c.Variable ?? Expression.Variable(c.Test, null); _vars.Add(deferredVar); // We need to ensure that filters can access the exception // variable Expression filter = c.Filter; if (filter != null && c.Variable != null) { filter = Expression.Block(new[] { c.Variable }, Expression.Assign(c.Variable, exceptionVar), filter); } // catch (ExceptionType exceptionVar) { // deferredVar = exceptionVar; // } handlers[i] = Expression.Catch( exceptionVar, Expression.Block( Expression.Assign(deferredVar, exceptionVar), Expression.Default(node.Body.Type) ), filter ); // We need to rewrite rethrows into "throw deferredVar" var catchBody = new RethrowRewriter { Exception = deferredVar }.Visit(c.Body); // if (deferredVar != null) { // ... catch body ... // } block.Add( Expression.Condition( Expression.NotEqual(deferredVar, AstUtils.Constant(null, deferredVar.Type)), catchBody, Expression.Default(node.Body.Type) ) ); } block[1] = Expression.MakeTry(null, @try, null, null, new ReadOnlyCollection <CatchBlock>(handlers)); @try = Expression.Block(block); handlers = new CatchBlock[0]; // so we don't reuse these } if (finallyYields != catchYields) { // We need to add a catch block to save the exception, so we // can rethrow in case there is a yield in the finally. Also, // add logic for returning. It looks like this: // // try { ... } catch (Exception all) { saved = all; } // finally { // if (_finallyReturnVar) goto finallyReturn; // ... // if (saved != null) throw saved; // finallyReturn: // } // if (_finallyReturnVar) goto _return; // We need to add a catch(Exception), so if we have catches, // wrap them in a try if (handlers.Count > 0) { @try = Expression.MakeTry(null, @try, null, null, handlers); handlers = new CatchBlock[0]; } // NOTE: the order of these routers is important // The first call changes the labels to all point at "tryEnd", // so the second router will jump to "tryEnd" var tryEnd = Expression.Label(); Expression inFinallyRouter = MakeYieldRouter(node.Body.Type, catchYields, finallyYields, tryEnd); Expression inTryRouter = MakeYieldRouter(node.Body.Type, catchYields, finallyYields, tryStart); var all = Expression.Variable(typeof(Exception), "e"); var saved = Expression.Variable(typeof(Exception), "$saved$" + _temps.Count); _temps.Add(saved); @try = Expression.Block( Expression.TryCatchFinally( Expression.Block( inTryRouter, @try, Expression.Assign(saved, AstUtils.Constant(null, saved.Type)), Expression.Label(tryEnd) ), Expression.Block( MakeSkipFinallyBlock(finallyReturn), inFinallyRouter, @finally, Expression.Condition( Expression.NotEqual(saved, AstUtils.Constant(null, saved.Type)), Expression.Throw(saved), Utils.Empty() ), Expression.Label(finallyReturn) ), Expression.Catch(all, Utils.Void(Expression.Assign(saved, all))) ), Expression.Condition( Expression.Equal(_gotoRouter, AstUtils.Constant(GotoRouterYielding)), Expression.Goto(_returnLabels.Peek()), Utils.Empty() ) ); @finally = null; } else if (@finally != null) { // try or catch had a yield, modify finally so we can skip over it @finally = Expression.Block( MakeSkipFinallyBlock(finallyReturn), @finally, Expression.Label(finallyReturn) ); } // Make the outer try, if needed if (handlers.Count > 0 || @finally != null || fault != null) { @try = Expression.MakeTry(null, @try, @finally, fault, handlers); } return(Expression.Block(Expression.Label(tryStart), @try)); }
protected override Expression VisitTry(TryExpression node) { // Visit finally/fault block first BlockInfo block = new BlockInfo { InFinally = true }; _blocks.Push(block); Expression @finally = Visit(node.Finally); Expression fault = Visit(node.Fault); block.InFinally = false; LabelTarget finallyEnd = block.FlowLabel; if (finallyEnd != null) { // Make a new target, which will be emitted after the try block.FlowLabel = Expression.Label(); } Expression @try = Visit(node.Body); IList <CatchBlock> handlers = Visit(node.Handlers, VisitCatchBlock); _blocks.Pop(); if (@try == node.Body && handlers == node.Handlers && @finally == node.Finally && fault == node.Fault) { return(node); } if (!block.HasFlow) { return(Expression.MakeTry(null, @try, @finally, fault, handlers)); } if (node.Type != typeof(void)) { // This is not hard to support in principle, but not needed by anyone yet. throw new NotSupportedException("FinallyFlowControlExpression does not support TryExpressions of non-void type."); } // If there is a control flow in finally, emit outer: // try { // // try block body and all catch handling // } catch (Exception all) { // saved = all; // } finally { // finally_body // if (saved != null) { // throw saved; // } // } // // If we have a fault handler we turn this into the better: // try { // // try block body and all catch handling // } catch (Exception all) { // fault_body // throw all // } if (handlers.Count > 0) { @try = Expression.MakeTry(null, @try, null, null, handlers); } var saved = Expression.Variable(typeof(Exception), "$exception"); var all = Expression.Variable(typeof(Exception), "e"); if (@finally != null) { handlers = new[] { Expression.Catch( all, Expression.Block( Expression.Assign(saved, all), Utils.Default(node.Type) ) ) }; @finally = Expression.Block( @finally, Expression.Condition( Expression.NotEqual(saved, AstUtils.Constant(null, saved.Type)), Expression.Throw(saved), Utils.Empty() ) ); if (finallyEnd != null) { @finally = Expression.Label(finallyEnd, @finally); } } else { Debug.Assert(fault != null); fault = Expression.Block(fault, Expression.Throw(all)); if (finallyEnd != null) { fault = Expression.Label(finallyEnd, fault); } handlers = new[] { Expression.Catch(all, fault) }; fault = null; } // Emit flow control return(Expression.Block( new[] { saved }, Expression.MakeTry(null, @try, @finally, fault, handlers), Expression.Label(block.FlowLabel), MakeFlowControlSwitch(block) )); }
protected override Expression VisitTry(TryExpression node) { int startYields = _yields.Count; bool savedInTryWithFinally = _inTryWithFinally; if (node.Finally != null || node.Fault != null) { _inTryWithFinally = true; } Expression @try = Visit(node.Body); int tryYields = _yields.Count; IList <CatchBlock> handlers = Visit(node.Handlers, VisitCatchBlock); int catchYields = _yields.Count; // push a new return label in case the finally block yields _returnLabels.Push(Expression.Label()); // only one of these can be non-null Expression @finally = Visit(node.Finally); Expression fault = Visit(node.Fault); LabelTarget finallyReturn = _returnLabels.Pop(); int finallyYields = _yields.Count; _inTryWithFinally = savedInTryWithFinally; if (@try == node.Body && handlers == node.Handlers && @finally == node.Finally && fault == node.Fault) { return(node); } // No yields, just return if (startYields == _yields.Count) { return(Expression.MakeTry(@try, @finally, fault, handlers)); } if (fault != null && finallyYields != catchYields) { // No one needs this yet, and it's not clear how we should get back to // the fault throw new NotSupportedException("yield in fault block is not supported"); } // If try has yields, we need to build a new try body that // dispatches to the yield labels var tryStart = Expression.Label(); if (tryYields != startYields) { @try = Expression.Block(MakeYieldRouter(startYields, tryYields, tryStart), @try); } // Transform catches with yield to deferred handlers if (catchYields != tryYields) { // Temps which are only needed temporarily, so they can go into // a transient scope (contents will be lost each yield) var temps = new List <ParameterExpression>(); var block = new List <Expression>(); block.Add(MakeYieldRouter(tryYields, catchYields, tryStart)); block.Add(null); // empty slot to fill in later for (int i = 0, n = handlers.Count; i < n; i++) { CatchBlock c = handlers[i]; if (c == node.Handlers[i]) { continue; } if (handlers.IsReadOnly) { handlers = handlers.ToArray(); } // TODO: when CatchBlock's variable is scoped properly, this // implementation will need to be different var deferredVar = Expression.Variable(c.Test, null); temps.Add(deferredVar); handlers[i] = Expression.Catch(deferredVar, Expression.Empty(), c.Filter); // We need to rewrite rethrows into "throw deferredVar" var catchBody = new RethrowRewriter { Exception = deferredVar }.Visit(c.Body); if (c.Variable != null) { catchBody = Expression.Block(Expression.Assign(c.Variable, deferredVar), catchBody); } else { catchBody = Expression.Block(catchBody); } block.Add( Expression.Condition( Expression.NotEqual(deferredVar, Expression.Constant(null, deferredVar.Type)), Expression.Void(catchBody), Expression.Empty() ) ); } block[1] = Expression.MakeTry(@try, null, null, new ReadOnlyCollection <CatchBlock>(handlers)); @try = Expression.Block(temps, block); handlers = new CatchBlock[0]; // so we don't reuse these } if (finallyYields != catchYields) { // We need to add a catch block to save the exception, so we // can rethrow in case there is a yield in the finally. Also, // add logic for returning. It looks like this: // try { ... } catch (Exception e) {} // finally { // if (_finallyReturnVar) goto finallyReturn; // ... // if (e != null) throw e; // finallyReturn: // } // if (_finallyReturnVar) goto _return; // We need to add a catch(Exception), so if we have catches, // wrap them in a try if (handlers.Count > 0) { @try = Expression.MakeTry(@try, null, null, handlers); handlers = new CatchBlock[0]; } // NOTE: the order of these routers is important // The first call changes the labels to all point at "tryEnd", // so the second router will jump to "tryEnd" var tryEnd = Expression.Label(); Expression inFinallyRouter = MakeYieldRouter(catchYields, finallyYields, tryEnd); Expression inTryRouter = MakeYieldRouter(catchYields, finallyYields, tryStart); var exception = Expression.Variable(typeof(Exception), "$temp$" + _temps.Count); _temps.Add(exception); @try = Expression.Block( Expression.TryCatchFinally( Expression.Block( inTryRouter, @try, Expression.Assign(exception, Expression.Constant(null, exception.Type)), Expression.Label(tryEnd) ), Expression.Block( MakeSkipFinallyBlock(finallyReturn), inFinallyRouter, @finally, Expression.Condition( Expression.NotEqual(exception, Expression.Constant(null, exception.Type)), Expression.Throw(exception), Expression.Empty() ), Expression.Label(finallyReturn) ), Expression.Catch(exception, Expression.Empty()) ), Expression.Condition( Expression.Equal(_gotoRouter, Expression.Constant(GotoRouterYielding)), Expression.Goto(_returnLabels.Peek()), Expression.Empty() ) ); @finally = null; } else if (@finally != null) { // try or catch had a yield, modify finally so we can skip over it @finally = Expression.Block( MakeSkipFinallyBlock(finallyReturn), @finally, Expression.Label(finallyReturn) ); } // Make the outer try, if needed if (handlers.Count > 0 || @finally != null || fault != null) { @try = Expression.MakeTry(@try, @finally, fault, handlers); } return(Expression.Block(Expression.Label(tryStart), @try)); }
protected override Expression VisitTry(TryExpression node) { // Visit finally/fault block first BlockInfo block = new BlockInfo { InFinally = true }; _blocks.Push(block); Expression @finally = Visit(node.Finally); Expression fault = Visit(node.Fault); block.InFinally = false; LabelTarget finallyEnd = block.FlowLabel; if (finallyEnd != null) { if (@finally != null) { @finally = Expression.Label(finallyEnd, @finally); } if (fault != null) { fault = Expression.Label(finallyEnd, fault); } // Make a new target, which will be emitted after the try block.FlowLabel = Expression.Label(); } Expression @try = Visit(node.Body); IList <CatchBlock> handlers = Visit(node.Handlers, VisitCatchBlock); _blocks.Pop(); if (@try == node.Body && handlers == node.Handlers && @finally == node.Finally && fault == node.Fault) { return(node); } if (!block.HasFlow) { return(Expression.MakeTry(@try, @finally, fault, handlers)); } // If there is a control flow in finally, emit outer: // try { // // try block body and all catch handling // } catch (Exception all) { // saved = all; // } finally { // finally_body // if (saved != null) { // throw saved; // } // } // // If we have a fault handler we turn this into the better: // try { // // try block body and all catch handling // } catch (Exception all) { // saved = all; // fault_body // throw saved // } if (handlers.Count > 0) { @try = Expression.MakeTry(@try, null, null, handlers); } var all = Expression.Variable(typeof(Exception), "$exception"); if (@finally != null) { handlers = new[] { Expression.Catch(all.Type, Expression.Empty()) }; @finally = Expression.Block( @finally, Expression.Condition( Expression.NotEqual(all, Expression.Constant(null, all.Type)), Expression.Throw(all), Expression.Empty() ) ); } else { handlers = new[] { Expression.Catch( all.Type, Expression.Block(fault, Expression.Throw(all)) ) }; fault = null; } // Emit flow control return(Expression.Block( new ParameterExpression[] { all }, Expression.MakeTry(@try, @finally, fault, handlers), Expression.Label(block.FlowLabel), MakeFlowControlSwitch(block) )); }