Adding async/await support to the Boo language!

ast.model.boo

@@ -551,6 +551,12 @@ class CastExpression(Expression):
 class TypeofExpression(Expression):
 	Type as TypeReference
 
+class AsyncBlockExpression(BlockExpression):
+	Block as BlockExpression
+
+class AwaitExpression(Expression):
+	BaseExpression as Expression
+
 class CustomStatement(Statement):
 	pass
 

src/Boo.Lang.Compiler/Ast/AsyncBlockExpression.cs

@@ -0,0 +1,52 @@
+#region license
+// Copyright (c) 2009 Rodrigo B. de Oliveira ([email protected])
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+// 
+//     * Redistributions of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//     * Neither the name of Rodrigo B. de Oliveira nor the names of its
+//     contributors may be used to endorse or promote products derived from this
+//     software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+namespace Boo.Lang.Compiler.Ast
+{
+	using System;
+
+	public partial class AsyncBlockExpression
+	{
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		public AsyncBlockExpression()
+		{
+		}
+
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		public AsyncBlockExpression(LexicalInfo lexicalInfo) : base(lexicalInfo)
+		{
+		}
+
+	    public AsyncBlockExpression(BlockExpression value) : base(value.LexicalInfo)
+	    {
+	        _block = value;
+            _block.InitializeParent(this);
+	    }
+	}
+}
+

src/Boo.Lang.Compiler/Ast/AwaitExpression.cs

@@ -0,0 +1,25 @@
+using Boo.Lang.Compiler.TypeSystem;
+
+namespace Boo.Lang.Compiler.Ast
+{
+    public partial class AwaitExpression
+    {
+        [System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+        public AwaitExpression()
+        {
+        }
+
+        [System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+        public AwaitExpression(LexicalInfo lexicalInfo)
+            : base(lexicalInfo)
+        {
+        }
+
+        public AwaitExpression(Expression baseExpression)
+            : base(baseExpression.LexicalInfo)
+        {
+            _baseExpression = baseExpression;
+            _baseExpression.InitializeParent(this);
+        }
+    }
+}

src/Boo.Lang.Compiler/Ast/IAstVisitor.Generated.cs

@@ -124,6 +124,8 @@ public interface IAstVisitor
 		void OnTryCastExpression(TryCastExpression node);
 		void OnCastExpression(CastExpression node);
 		void OnTypeofExpression(TypeofExpression node);
+		void OnAsyncBlockExpression(AsyncBlockExpression node);
+		void OnAwaitExpression(AwaitExpression node);
 		void OnCustomStatement(CustomStatement node);
 		void OnCustomExpression(CustomExpression node);
 		void OnStatementTypeMember(StatementTypeMember node);

src/Boo.Lang.Compiler/Ast/Impl/AsyncBlockExpressionImpl.cs

@@ -0,0 +1,208 @@
+#region license
+// Copyright (c) 2009 Rodrigo B. de Oliveira ([email protected])
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+// 
+//     * Redistributions of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//     * Neither the name of Rodrigo B. de Oliveira nor the names of its
+//     contributors may be used to endorse or promote products derived from this
+//     software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+//
+// DO NOT EDIT THIS FILE!
+//
+// This file was generated automatically by astgen.boo.
+//
+namespace Boo.Lang.Compiler.Ast
+{	
+	using System.Collections;
+	using System.Runtime.Serialization;
+
+	[System.Serializable]
+	public partial class AsyncBlockExpression : BlockExpression
+	{
+		protected BlockExpression _block;
+
+
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		new public AsyncBlockExpression CloneNode()
+		{
+			return (AsyncBlockExpression)Clone();
+		}
+
+		/// <summary>
+		/// <see cref="Node.CleanClone"/>
+		/// </summary>
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		new public AsyncBlockExpression CleanClone()
+		{
+			return (AsyncBlockExpression)base.CleanClone();
+		}
+
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		override public NodeType NodeType
+		{
+			get { return NodeType.AsyncBlockExpression; }
+		}
+
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		override public void Accept(IAstVisitor visitor)
+		{
+			visitor.OnAsyncBlockExpression(this);
+		}
+
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		override public bool Matches(Node node)
+		{	
+			if (node == null) return false;
+			if (NodeType != node.NodeType) return false;
+			var other = ( AsyncBlockExpression)node;
+			if (!Node.AllMatch(_parameters, other._parameters)) return NoMatch("AsyncBlockExpression._parameters");
+			if (!Node.Matches(_returnType, other._returnType)) return NoMatch("AsyncBlockExpression._returnType");
+			if (!Node.Matches(_body, other._body)) return NoMatch("AsyncBlockExpression._body");
+			if (!Node.Matches(_block, other._block)) return NoMatch("AsyncBlockExpression._block");
+			return true;
+		}
+
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		override public bool Replace(Node existing, Node newNode)
+		{
+			if (base.Replace(existing, newNode))
+			{
+				return true;
+			}
+			if (_parameters != null)
+			{
+				ParameterDeclaration item = existing as ParameterDeclaration;
+				if (null != item)
+				{
+					ParameterDeclaration newItem = (ParameterDeclaration)newNode;
+					if (_parameters.Replace(item, newItem))
+					{
+						return true;
+					}
+				}
+			}
+			if (_returnType == existing)
+			{
+				this.ReturnType = (TypeReference)newNode;
+				return true;
+			}
+			if (_body == existing)
+			{
+				this.Body = (Block)newNode;
+				return true;
+			}
+			if (_block == existing)
+			{
+				this.Block = (BlockExpression)newNode;
+				return true;
+			}
+			return false;
+		}
+
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		override public object Clone()
+		{
+
+			AsyncBlockExpression clone = new AsyncBlockExpression();
+			clone._lexicalInfo = _lexicalInfo;
+			clone._endSourceLocation = _endSourceLocation;
+			clone._documentation = _documentation;
+			clone._isSynthetic = _isSynthetic;
+			clone._entity = _entity;
+			if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
+			clone._expressionType = _expressionType;
+			if (null != _parameters)
+			{
+				clone._parameters = _parameters.Clone() as ParameterDeclarationCollection;
+				clone._parameters.InitializeParent(clone);
+			}
+			if (null != _returnType)
+			{
+				clone._returnType = _returnType.Clone() as TypeReference;
+				clone._returnType.InitializeParent(clone);
+			}
+			if (null != _body)
+			{
+				clone._body = _body.Clone() as Block;
+				clone._body.InitializeParent(clone);
+			}
+			if (null != _block)
+			{
+				clone._block = _block.Clone() as BlockExpression;
+				clone._block.InitializeParent(clone);
+			}
+			return clone;
+
+
+		}
+
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		override internal void ClearTypeSystemBindings()
+		{
+			_annotations = null;
+			_entity = null;
+			_expressionType = null;
+			if (null != _parameters)
+			{
+				_parameters.ClearTypeSystemBindings();
+			}
+			if (null != _returnType)
+			{
+				_returnType.ClearTypeSystemBindings();
+			}
+			if (null != _body)
+			{
+				_body.ClearTypeSystemBindings();
+			}
+			if (null != _block)
+			{
+				_block.ClearTypeSystemBindings();
+			}
+
+		}
+
+
+		[System.Xml.Serialization.XmlElement]
+		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
+		public BlockExpression Block
+		{
+
+			get { return _block; }
+			set
+			{
+				if (_block != value)
+				{
+					_block = value;
+					if (null != _block)
+					{
+						_block.InitializeParent(this);
+					}
+				}
+			}
+
+		}
+
+
+	}
+}
+