Support for "finally" clauses

Source/ReferenceTests/Language/TryCatchFinallyTests.cs

@@ -0,0 +1,40 @@
+using System;
+using NUnit.Framework;
+
+namespace ReferenceTests.Language
+{
+    [TestFixture]
+    public class TryCatchFinallyTests : ReferenceTestBase
+    {
+        [Test]
+        public void TryFinallyWithoutCatch()
+        {
+            ExecuteAndCompareTypedResult(
+                "try { 2 + 2 } finally { 0 }",
+                4,
+                0
+            );                
+        }
+
+        [Test]
+        public void TryCatchFinally()
+        {
+            ExecuteAndCompareTypedResult(
+                "try { 2 + 2 } catch { -1 } finally { 0 }",
+                4,
+                0
+            );
+        }
+
+        [Test]
+        public void TryCatchFinallyWithException()
+        {
+            ExecuteAndCompareTypedResult(
+                "try { 2 / 0 } catch { -1 } finally { 3 }",
+                -1,
+                3
+            );
+        }
+    }
+}
+

Source/ReferenceTests/ReferenceTests.csproj

@@ -132,6 +132,7 @@
     <Compile Include="TestUtil.cs" />
     <Compile Include="Commands\ConvertToSecureStringTests.cs" />
     <Compile Include="Language\ExpressionTests.cs" />
+    <Compile Include="Language\TryCatchFinallyTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\System.Management\System.Management.csproj">

Source/System.Management/Pash/Implementation/ExecutionVisitor.cs

@@ -1322,8 +1322,16 @@ public override AstVisitAction VisitTryStatement(TryStatementAst tryStatementAst
             {
                 SetUnderscoreVariable(ex);
 
+                // not yet considered: no catches, special catches!
                 tryStatementAst.CatchClauses.Last().Body.Visit(this);
             }
+            finally
+            {
+                if (tryStatementAst.Finally != null)
+                {
+                    tryStatementAst.Finally.Visit(this);
+                }
+            }
 
             return AstVisitAction.SkipChildren;
         }

Source/System.Management/Pash/ParserIntrinsics/AstBuilder.cs

@@ -424,11 +424,20 @@ private StatementAst BuildBreakStatementAst(ParseTreeNode parseTreeNode)
 
         StatementAst BuildTryStatementAst(ParseTreeNode parseTreeNode)
         {
+            var subClauses = parseTreeNode.ChildNodes[0].ChildNodes;
+            var catchClauses = subClauses[2];
+            var finallyClause = subClauses.Count > 3 ? subClauses[3] : null;
+            // there might be no catch clauses, then a finally clause could follow directly
+            if (catchClauses.Term == this._grammar.finally_clause)
+            {
+                finallyClause = catchClauses;
+                catchClauses = null;
+            }
             return new TryStatementAst(
                 new ScriptExtent(parseTreeNode),
-                BuildStatementBlockAst(parseTreeNode.ChildNodes[0].ChildNodes[1]),
-                BuildCatchClausesAst(parseTreeNode.ChildNodes[0].ChildNodes[2]),
-                null
+                BuildStatementBlockAst(subClauses[1]),
+                catchClauses == null ? Enumerable.Empty<CatchClauseAst>() : BuildCatchClausesAst(catchClauses),
+                finallyClause == null ? null : BuildFinallyClauseAst(finallyClause)
                 );
         }
 
@@ -452,6 +461,13 @@ private CatchClauseAst BuildCatchClauseAst(ParseTreeNode parseTreeNode)
                 );
         }
 
+        StatementBlockAst BuildFinallyClauseAst(ParseTreeNode finallyClause)
+        {
+            VerifyTerm(finallyClause, this._grammar.finally_clause);
+
+            return BuildStatementBlockAst(finallyClause.ChildNodes[1]);
+        }
+
         StatementAst BuildDataStatementAst(ParseTreeNode parseTreeNode)
         {
             throw new NotImplementedException();