code gardening

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

@@ -38,7 +38,7 @@ namespace Boo.Lang.Compiler.Ast
 	using System.Collections.Generic;
 	using System.Text.RegularExpressions;
 
-	public class AstUtil
+	public static class AstUtil
 	{
 		public static bool IsOverloadableOperator(BinaryOperatorType op)
 		{
@@ -72,12 +72,12 @@ public static bool IsOverloadableOperator(BinaryOperatorType op)
 
 		public static string GetMethodNameForOperator(BinaryOperatorType op)
 		{
-			return "op_" + op.ToString();
+			return "op_" + op;
 		}
 
 		public static string GetMethodNameForOperator(UnaryOperatorType op)
 		{
-			return "op_" + op.ToString();
+			return "op_" + op;
 		}
 
 		public static bool IsComplexSlicing(SlicingExpression node)
@@ -329,11 +329,12 @@ public static bool IsLhsOfInPlaceAddSubtract(Expression node)
 		{
 			if (NodeType.BinaryExpression == node.ParentNode.NodeType)
 			{
-				BinaryExpression be = (BinaryExpression)node.ParentNode;
+				var be = (BinaryExpression)node.ParentNode;
 				if (node == be.Left)
 				{
-					BinaryOperatorType op = be.Operator;
-					return op == BinaryOperatorType.InPlaceAddition || op == BinaryOperatorType.InPlaceSubtraction;
+					var op = be.Operator;
+					return op == BinaryOperatorType.InPlaceAddition
+						|| op == BinaryOperatorType.InPlaceSubtraction;
 				}
 			}
 			return false;
@@ -349,10 +350,7 @@ public static bool IsStandaloneReference(Node node)
 
 		public static Constructor CreateConstructor(Node lexicalInfoProvider, TypeMemberModifiers modifiers)
 		{
-			Constructor constructor = new Constructor(lexicalInfoProvider.LexicalInfo);
-			constructor.Modifiers = modifiers;
-			constructor.IsSynthetic = true;
-			return constructor;
+			return new Constructor(lexicalInfoProvider.LexicalInfo) { Modifiers = modifiers, IsSynthetic = true };
 		}
 
 		public static Constructor CreateDefaultConstructor(TypeDefinition type)
@@ -386,33 +384,27 @@ public static MethodInvocationExpression CreateMethodInvocationExpression(Expres
 
 		public static MethodInvocationExpression CreateMethodInvocationExpression(LexicalInfo li, Expression target, Expression arg)
 		{
-			MethodInvocationExpression mie = new MethodInvocationExpression(li);
-			mie.Target = (Expression)target.Clone();			
+			var mie = new MethodInvocationExpression(li) { Target = (Expression) target.Clone(), IsSynthetic = true };
 			mie.Arguments.Add((Expression)arg.Clone());
-			mie.IsSynthetic = true;
 			return mie;
 		}
 
 		public static bool IsExplodeExpression(Node node)
 		{
-			UnaryExpression e = node as UnaryExpression;
-			return null == e ? false : e.Operator == UnaryOperatorType.Explode;
+			var e = node as UnaryExpression;
+			return e == null ? false : e.Operator == UnaryOperatorType.Explode;
 		}
 
 		public static bool IsIndirection(Node node)
 		{
 			var e = node as UnaryExpression;
-			return null == e ? false : e.Operator == UnaryOperatorType.Indirection;
-		}
-
-		private AstUtil()
-		{
+			return e == null ? false : e.Operator == UnaryOperatorType.Indirection;
 		}
 
 		public static string ToXml(Node node)
 		{
-			StringWriter writer = new StringWriter();
-			XmlSerializer serializer = new XmlSerializer(node.GetType());
+			var writer = new StringWriter();
+			var serializer = new XmlSerializer(node.GetType());
 			serializer.Serialize(writer, node);
 			return writer.ToString();
 		}
@@ -445,20 +437,18 @@ public static string SafeToCodeString(Node node)
 		//use this to build a type member name unique in the inheritance hierarchy.
 		public static string BuildUniqueTypeMemberName(TypeDefinition type, string name)
 		{
-			if (String.IsNullOrEmpty(name))
+			if (string.IsNullOrEmpty(name))
 				throw new ArgumentNullException("name");
 
-			StringBuilder nameBuilder = new StringBuilder("$");
+			var nameBuilder = new StringBuilder("$");
 			nameBuilder.Append(name);
 			nameBuilder.Append("__");
 			nameBuilder.Append(type.QualifiedName);
 			if (type.HasGenericParameters)
 			{
 				nameBuilder.Append("_");
-				string[] parameterNames = Array.ConvertAll(
-					type.GenericParameters.ToArray(),
-					delegate(GenericParameterDeclaration gpd) { return gpd.Name; });
-				foreach (string parameterName in parameterNames)
+
+				foreach (var parameterName in type.GenericParameters.Select(gpd => gpd.Name))
 				{
 					nameBuilder.Append("_");
 					nameBuilder.Append(parameterName);
@@ -479,36 +469,31 @@ internal static Local GetLocalByName(Method method, string name)
 
 		public static LexicalInfo SafeLexicalInfo(Node node)
 		{
-			if (null == node) return LexicalInfo.Empty;
-			LexicalInfo info = node.LexicalInfo;
-			if (info.IsValid) return info;
-			return SafeLexicalInfo(node.ParentNode);
+			if (node == null)
+				return LexicalInfo.Empty;
+			var info = node.LexicalInfo;
+			return info.IsValid ? info : SafeLexicalInfo(node.ParentNode);
 		}
 
 		public static string SafePositionOnlyLexicalInfo(Node node)
 		{
-			LexicalInfo info = SafeLexicalInfo(node);
-			return String.Format("({0},{1})", info.Line, info.Column);
+			var info = SafeLexicalInfo(node);
+			return string.Format("({0},{1})", info.Line, info.Column);
 		}
 
 		public static ICollection<TValue> GetValues<TNode, TValue>(NodeCollection<TNode> nodes)
 			where TNode : LiteralExpression
 		{
-			List<TValue> values = new List<TValue>(nodes.Count);
-
-			foreach (TNode node in nodes)
-				values.Add((TValue) Convert.ChangeType(node.ValueObject, typeof(TValue)));
-
-			return values;
+			return nodes.Select(node => (TValue) Convert.ChangeType(node.ValueObject, typeof(TValue))).ToList();
 		}
 
 		internal static bool AllCodePathsReturnOrRaise(Block block)
 		{
-			if (null == block || block.IsEmpty)
+			if (block == null || block.IsEmpty)
 				return false;
 
-			Node node = block.LastStatement;
-			NodeType last = node.NodeType;
+			var node = block.LastStatement;
+			var last = node.NodeType;
 			switch (last)
 			{
 				case NodeType.ReturnStatement:
@@ -519,23 +504,18 @@ internal static bool AllCodePathsReturnOrRaise(Block block)
 					return AllCodePathsReturnOrRaise((Block)node);
 
 				case NodeType.IfStatement:
-					IfStatement ifstmt = (IfStatement) node;
+					var ifstmt = (IfStatement) node;
 					return
 						AllCodePathsReturnOrRaise(ifstmt.TrueBlock)
 						&& AllCodePathsReturnOrRaise(ifstmt.FalseBlock);
 
 				case NodeType.TryStatement:
-					TryStatement ts = (TryStatement) node;
+					var ts = (TryStatement) node;
 					if (!AllCodePathsReturnOrRaise(ts.ProtectedBlock))
 						return false;
 					//if (null != ts.FailureBlock && !EndsWithReturnStatement(ts.FailureBlock))
 					//	return false;
-					foreach (ExceptionHandler handler in ts.ExceptionHandlers)
-					{
-						if (!AllCodePathsReturnOrRaise(handler.Block))
-							return false;
-					}
-					return true;
+					return ts.ExceptionHandlers.Select(handler => handler.Block).All(AllCodePathsReturnOrRaise);
 			}
 			return false;
 		}

src/Boo.Lang.Compiler/Steps/AbstractFastVisitorCompilerStep.cs

@@ -36,13 +36,31 @@ namespace Boo.Lang.Compiler.Steps
 {
 	public class AbstractFastVisitorCompilerStep : FastDepthFirstVisitor, ICompilerStep
 	{
-		private CompilerContext _context;
+		public virtual void Run()
+		{
+			CompileUnit.Accept(this);
+		}
+
+		public virtual void Initialize(CompilerContext context)
+		{
+			_context = context;
+			_codeBuilder = new EnvironmentProvision<BooCodeBuilder>();
+			_typeSystemServices = new EnvironmentProvision<TypeSystemServices>();
+			_nameResolutionService = new EnvironmentProvision<NameResolutionService>();
+		}
+
+		public virtual void Dispose()
+		{
+			_context = null;
+		}
 
 		protected CompilerContext Context
 		{
 			get { return _context; }
 		}
 
+		private CompilerContext _context;
+
 		protected CompilerErrorCollection Errors
 		{
 			get { return _context.Errors; }
@@ -136,24 +154,6 @@ protected void BindExpressionType(Expression node, IType type)
 			node.ExpressionType = type;
 		}
 
-		public virtual void Initialize(CompilerContext context)
-		{
-			_context = context;
-			_codeBuilder = new EnvironmentProvision<BooCodeBuilder>();
-			_typeSystemServices = new EnvironmentProvision<TypeSystemServices>();
-			_nameResolutionService = new EnvironmentProvision<NameResolutionService>();
-		}
-
-		public virtual void Dispose()
-		{
-			_context = null;
-		}
-
-		public virtual void Run()
-		{
-			CompileUnit.Accept(this);
-		}
-
 		protected CompileUnit CompileUnit
 		{
 			get { return _context.CompileUnit; }

src/Boo.Lang.Compiler/Steps/EmitAssembly.cs

@@ -4385,13 +4385,6 @@ CustomAttributeBuilder CreateRuntimeCompatibilityAttribute()
 					RuntimeCompatibilityAttribute_Property, new object[] { true });
 		}
 
-		CustomAttributeBuilder CreateSerializableAttribute()
-		{
-			return new CustomAttributeBuilder(
-				SerializableAttribute_Constructor,
-				new object[0]);
-		}
-
 		CustomAttributeBuilder CreateUnverifiableCodeAttribute()
 		{
 			return new CustomAttributeBuilder(Methods.ConstructorOf(() => new UnverifiableCodeAttribute()), new object[0]);