Merge pull request #44 from NN---/annotations

Add code annotations.

Author: ig-sinicyn

CodeJam.Blocks/Mapping/CodeJamConvertException.cs

@@ -50,7 +50,7 @@ public CodeJamConvertException(string message)
 		/// the current exception.</param>
 		/// <seealso cref="Exception.Message"/>
 		/// <seealso cref="Exception.InnerException"/>
-		public CodeJamConvertException(string message, Exception innerException) 
+		public CodeJamConvertException(string message, Exception innerException)
 			: base(message, innerException)
 		{
 		}
@@ -62,7 +62,7 @@ public CodeJamConvertException(string message, Exception innerException)
 		/// <param name="innerException">The InnerException, if any, that threw
 		/// the current exception.</param>
 		/// <seealso cref="Exception.InnerException"/>
-		public CodeJamConvertException(Exception innerException) 
+		public CodeJamConvertException([NotNull] Exception innerException)
 			: base(innerException.Message, innerException)
 		{
 		}
@@ -76,7 +76,7 @@ public CodeJamConvertException(Exception innerException)
 		/// destination.</param>
 		/// <remarks>This constructor is called during deserialization to
 		/// reconstitute the exception object transmitted over a stream.</remarks>
-		protected CodeJamConvertException(SerializationInfo info, StreamingContext context)
+		protected CodeJamConvertException([NotNull] SerializationInfo info, StreamingContext context)
 			: base(info, context)
 		{
 		}

CodeJam.Blocks/Mapping/CodeJamMappingException.cs

@@ -1,4 +1,4 @@
-#if !LESSTHAN_NET40
+#if !LESSTHAN_NET40
 using System;
 using System.Runtime.Serialization;
 
@@ -60,7 +60,7 @@ public CodeJamMappingException(string message, Exception innerException)
 		/// <param name="innerException">The InnerException, if any, that threw
 		/// the current exception.</param>
 		/// <seealso cref="Exception.InnerException"/>
-		public CodeJamMappingException(Exception innerException)
+		public CodeJamMappingException([NotNull] Exception innerException)
 			: base(innerException.Message, innerException)
 		{
 		}
@@ -75,7 +75,7 @@ public CodeJamMappingException(Exception innerException)
 		/// destination.</param>
 		/// <remarks>This constructor is called during deserialization to
 		/// reconstitute the exception object transmitted over a stream.</remarks>
-		protected CodeJamMappingException(SerializationInfo info, StreamingContext context)
+		protected CodeJamMappingException([NotNull] SerializationInfo info, StreamingContext context)
 			: base(info, context)
 		{
 		}

CodeJam.Blocks/Mapping/ConvertBuilder.cs

@@ -11,15 +11,18 @@
 using CodeJam.Collections;
 using CodeJam.Expressions;
 
+using JetBrains.Annotations;
+
 namespace CodeJam.Mapping
 {
 	using Reflection;
 
 	internal static class ConvertBuilder
 	{
+		[NotNull]
 		private static readonly MethodInfo _defaultConverter = InfoOf.Method(() => ConvertDefault(null, typeof(int)));
 
-		private static object ConvertDefault(object value, Type conversionType)
+		private static object ConvertDefault(object value, [NotNull] Type conversionType)
 		{
 			try
 			{
@@ -31,7 +34,8 @@ private static object ConvertDefault(object value, Type conversionType)
 			}
 		}
 
-		private static Expression GetCtor(Type from, Type to, Expression p)
+		[CanBeNull]
+		private static Expression GetCtor([NotNull] Type from, [NotNull] Type to, [NotNull] Expression p)
 		{
 			var ctor = to.GetConstructor(new[] { from });
 
@@ -46,7 +50,8 @@ private static Expression GetCtor(Type from, Type to, Expression p)
 			return Expression.New(ctor, p);
 		}
 
-		private static Expression GetValue(Type from, Type to, Expression p)
+		[CanBeNull]
+		private static Expression GetValue([NotNull] Type from, [NotNull] Type to, [NotNull] Expression p)
 		{
 			var pi = from.GetProperty("Value");
 
@@ -66,7 +71,7 @@ private static Expression GetValue(Type from, Type to, Expression p)
 		private const BindingFlags _methodLookup =
 			BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
 
-		private static Expression GetOperator(Type from, Type to, Expression p)
+		private static Expression GetOperator([NotNull] Type from, [NotNull] Type to, [NotNull] Expression p)
 		{
 			var op =
 				to.GetMethod("op_Implicit", _methodLookup, null, new[] { from }, null) ??
@@ -75,7 +80,7 @@ private static Expression GetOperator(Type from, Type to, Expression p)
 			return op != null ? Expression.Convert(p, to, op) : null;
 		}
 
-		private static bool IsConvertible(Type type)
+		private static bool IsConvertible([NotNull] Type type)
 		{
 			if (type.IsEnum)
 				return false;
@@ -99,7 +104,7 @@ private static bool IsConvertible(Type type)
 			}
 		}
 
-		private static Expression GetConvertion(Type from, Type to, Expression p)
+		private static Expression GetConvertion([NotNull] Type from, [NotNull] Type to, [NotNull] Expression p)
 		{
 			if (IsConvertible(from) && IsConvertible(to) && to != typeof(bool) ||
 				from.IsAssignableFrom(to) && to.IsAssignableFrom(from))
@@ -108,7 +113,7 @@ private static Expression GetConvertion(Type from, Type to, Expression p)
 			return null;
 		}
 
-		private static Expression GetParse(Type from, Type to, Expression p)
+		private static Expression GetParse([NotNull] Type from, [NotNull] Type to, [NotNull] Expression p)
 		{
 			if (from == typeof(string))
 			{
@@ -133,7 +138,7 @@ private static Expression GetParse(Type from, Type to, Expression p)
 			return null;
 		}
 
-		private static Expression GetToString(Type from, Type to, Expression p)
+		private static Expression GetToString([NotNull] Type from, [NotNull] Type to, [NotNull] Expression p)
 		{
 			if (to == typeof(string) && !from.IsNullable())
 			{
@@ -150,7 +155,7 @@ private static Expression GetToString(Type from, Type to, Expression p)
 			return null;
 		}
 
-		private static Expression GetParseEnum(Type from, Type to, Expression p)
+		private static Expression GetParseEnum([NotNull] Type from, [NotNull] Type to, [NotNull] Expression p)
 		{
 			if (from == typeof(string) && to.IsEnum)
 			{
@@ -210,7 +215,11 @@ into g
 
 		private static readonly MethodInfo _throwLinqToDBConvertException = InfoOf.Method(() => ThrowLinqToDBException(null));
 
-		private static Expression GetToEnum(Type from, Type to, Expression expression, MappingSchema mappingSchema)
+		private static Expression GetToEnum(
+			[NotNull] Type from,
+			[NotNull] Type to,
+			[NotNull] Expression expression,
+			[NotNull] MappingSchema mappingSchema)
 		{
 			if (to.IsEnum)
 			{

CodeJam.Blocks/Mapping/ConvertInfo.cs

@@ -4,10 +4,13 @@
 using System.Collections.Generic;
 using System.Linq.Expressions;
 
+using JetBrains.Annotations;
+
 namespace CodeJam.Mapping
 {
 	internal class ConvertInfo
 	{
+		[NotNull]
 		public static readonly ConvertInfo Default = new ConvertInfo();
 
 		public class LambdaInfo
@@ -30,27 +33,28 @@ public LambdaInfo(
 			public readonly bool IsSchemaSpecific;
 		}
 
+		[NotNull]
 		private readonly ConcurrentDictionary<Type, ConcurrentDictionary<Type, LambdaInfo>> _expressions =
 			new ConcurrentDictionary<Type, ConcurrentDictionary<Type, LambdaInfo>>();
 
-		public void Set(Type from, Type to, LambdaInfo expr) => Set(_expressions, from, to, expr);
+		public void Set([NotNull] Type from, [NotNull] Type to, [NotNull] LambdaInfo expr) => Set(_expressions, from, to, expr);
 
 		private static void Set(
-			IDictionary<Type, ConcurrentDictionary<Type, LambdaInfo>> expressions,
-			Type from,
-			Type to,
-			LambdaInfo expr)
+			[NotNull] IDictionary<Type, ConcurrentDictionary<Type, LambdaInfo>> expressions,
+			[NotNull] Type from,
+			[NotNull] Type to,
+			[NotNull] LambdaInfo expr)
 		{
 			if (!expressions.TryGetValue(from, out var dic))
 				expressions[from] = dic = new ConcurrentDictionary<Type, LambdaInfo>();
 
 			dic[to] = expr;
 		}
 
-		public LambdaInfo Get(Type from, Type to) =>
+		public LambdaInfo Get([NotNull] Type from, [NotNull] Type to) =>
 			_expressions.TryGetValue(from, out var dic) && dic.TryGetValue(to, out var li) ? li : null;
 
-		public LambdaInfo Create(MappingSchema mappingSchema, Type from, Type to)
+		public LambdaInfo Create([NotNull] MappingSchema mappingSchema, [NotNull] Type from, [NotNull] Type to)
 		{
 			var ex = ConvertBuilder.GetConverter(mappingSchema, from, to);
 			var lm = ex.Item1.Compile();

CodeJam.Blocks/Mapping/ConvertT.cs

@@ -62,7 +62,7 @@ public static Expression<Func<TFrom,TTo>> Expression
 			}
 		}
 
-		private static Func<TFrom,TTo> _lambda;
+		[NotNull] private static Func<TFrom,TTo> _lambda;
 
 		/// <summary>
 		/// Represents a function that converts a value of <i>TFrom</i> type to <i>TTo</i> type.
@@ -102,6 +102,7 @@ public static Func<TFrom,TTo> Lambda
 		/// <summary>
 		/// Returns a function that converts a value of <i>TFrom</i> type to <i>TTo</i> type.
 		/// </summary>
+		[NotNull]
 		public static Func<TFrom,TTo> From => _lambda;
 	}
 }

CodeJam.Blocks/Mapping/DefaultValue.cs

@@ -16,6 +16,7 @@ namespace CodeJam.Mapping
 	[PublicAPI]
 	public static class DefaultValue
 	{
+		[NotNull]
 		private static readonly ConcurrentDictionary<Type,object> _defaultValues = new ConcurrentDictionary<Type,object>
 		{
 			[typeof(int)]            = default(int),

CodeJam.Blocks/Mapping/DefaultValueExpression.cs

@@ -2,11 +2,13 @@
 using System;
 using System.Linq.Expressions;
 
+using JetBrains.Annotations;
+
 namespace CodeJam.Mapping
 {
 	internal class DefaultValueExpression : Expression
 	{
-		public DefaultValueExpression(MappingSchema mappingSchema, Type type)
+		public DefaultValueExpression([CanBeNull] MappingSchema mappingSchema, [NotNull] Type type)
 		{
 			_mappingSchema = mappingSchema;
 			Type          = type;

CodeJam.Blocks/Mapping/ExpressionBuilder.cs

@@ -8,6 +8,8 @@
 
 using CodeJam.Collections;
 
+using JetBrains.Annotations;
+
 using static System.Linq.Expressions.Expression;
 
 // ReSharper disable TailRecursiveCall
@@ -37,11 +39,11 @@ private class BuilderData
 			public bool IsRestart => RestartCounter > 10;
 		}
 
-		public ExpressionBuilder(IMapperBuilder mapperBuilder, ValueTuple<MemberInfo[],LambdaExpression>[] memberMappers)
+		public ExpressionBuilder([NotNull] IMapperBuilder mapperBuilder, ValueTuple<MemberInfo[],LambdaExpression>[] memberMappers)
 			: this(mapperBuilder, new BuilderData(memberMappers)) =>
 			_processCrossReferences = mapperBuilder.ProcessCrossReferences == true;
 
-		private ExpressionBuilder(IMapperBuilder mapperBuilder, BuilderData data)
+		private ExpressionBuilder([NotNull] IMapperBuilder mapperBuilder, BuilderData data)
 		{
 			_mapperBuilder          = mapperBuilder;
 			_data                   = data;
@@ -50,9 +52,13 @@ private ExpressionBuilder(IMapperBuilder mapperBuilder, BuilderData data)
 			_processCrossReferences = true;
 		}
 
+		[NotNull]
 		private readonly IMapperBuilder   _mapperBuilder;
+		[NotNull]
 		private readonly Type             _fromType;
+		[NotNull]
 		private readonly Type             _toType;
+		[NotNull]
 		private readonly BuilderData      _data;
 		private readonly bool             _processCrossReferences;
 
@@ -296,6 +302,7 @@ private MemberAssignment BuildAssignment(
 
 		#region GetExpression
 
+		[NotNull]
 		public LambdaExpression GetExpression()
 		{
 			var pFrom = Parameter(_fromType, "from");

CodeJam.Blocks/Mapping/IMapperBuilder.cs

@@ -73,12 +73,12 @@ public interface IMapperBuilder
 		/// <summary>
 		/// Type to map from.
 		/// </summary>
-		Type FromType { get; }
+		[NotNull] Type FromType { get; }
 
 		/// <summary>
 		/// Type to map to.
 		/// </summary>
-		Type ToType { get; }
+		[NotNull] Type ToType { get; }
 	}
 }
 #endif

CodeJam.Blocks/Mapping/MapperBuilder.cs

@@ -18,6 +18,7 @@ namespace CodeJam.Mapping
 	[PublicAPI]
 	public class MapperBuilder<TFrom, TTo> : IMapperBuilder
 	{
+		[NotNull]
 		private MappingSchema _mappingSchema = MappingSchema.Default;
 
 		/// <summary>
@@ -115,6 +116,7 @@ public MapperBuilder<TFrom, TTo> SetMemberFilter([NotNull] Func<MemberAccessor,
 		/// <param name="memberName">Type member name.</param>
 		/// <param name="mapName">Mapping name.</param>
 		/// <returns>Returns this mapper.</returns>
+		[NotNull]
 		public MapperBuilder<TFrom, TTo> FromMapping([NotNull] Type type, [NotNull] string memberName, [NotNull] string mapName)
 		{
 			Code.NotNull(type, nameof(type));
@@ -270,6 +272,7 @@ public MapperBuilder<TFrom, TTo> ToMapping(IReadOnlyDictionary<string, string> m
 		/// <param name="memberName">Type member name.</param>
 		/// <param name="mapName">Mapping name.</param>
 		/// <returns>Returns this mapper.</returns>
+		[NotNull]
 		public MapperBuilder<TFrom, TTo> Mapping(Type type, string memberName, string mapName)
 			=> FromMapping(type, memberName, mapName).ToMapping(type, memberName, mapName);
 
@@ -280,6 +283,7 @@ public MapperBuilder<TFrom, TTo> Mapping(Type type, string memberName, string ma
 		/// <param name="memberName">Type member name.</param>
 		/// <param name="mapName">Mapping name.</param>
 		/// <returns>Returns this mapper.</returns>
+		[NotNull]
 		public MapperBuilder<TFrom, TTo> Mapping<T>(string memberName, string mapName)
 			=> Mapping(typeof(T), memberName, mapName);
 
@@ -289,6 +293,7 @@ public MapperBuilder<TFrom, TTo> Mapping<T>(string memberName, string mapName)
 		/// <param name="memberName">Type member name.</param>
 		/// <param name="mapName">Mapping name.</param>
 		/// <returns>Returns this mapper.</returns>
+		[NotNull]
 		public MapperBuilder<TFrom, TTo> Mapping(string memberName, string mapName)
 			=> Mapping(typeof(TFrom), memberName, mapName).Mapping(typeof(TTo), memberName, mapName);
 
@@ -298,6 +303,7 @@ public MapperBuilder<TFrom, TTo> Mapping(string memberName, string mapName)
 		/// <param name="type">Type to map.</param>
 		/// <param name="mapping">Mapping parameters.</param>
 		/// <returns>Returns this mapper.</returns>
+		[NotNull]
 		public MapperBuilder<TFrom, TTo> Mapping([NotNull] Type type, [NotNull] IReadOnlyDictionary<string, string> mapping)
 		{
 			Code.NotNull(type, nameof(type));
@@ -402,6 +408,7 @@ public MapperBuilder<TFrom, TTo> SetDeepCopy(bool? deepCopy)
 		/// Gets an instance of <see cref="ExpressionBuilder"/> class.
 		/// </summary>
 		/// <returns><see cref="ExpressionBuilder"/>.</returns>
+		[NotNull]
 		internal ExpressionBuilder GetExpressionMapper()
 			=> new ExpressionBuilder(this, MemberMappers?.Select(mm => ValueTuple.Create(mm.Item1.GetMembersInfo(), mm.Item2)).ToArray());
 	}