Catch practices: avoid losing catched exception information. (#1555)

fredericDelaporte · web-flow · commit f0644cfc1c94 · 2018-01-25T13:13:13.000+01:00
* Catch practices: avoid losing catched exception information.

All catches have been reviewed for avoiding losing original exception information:

 * When another exception is raised, it should embed the original one as an inner exception.
 * Otherwise when re-thrown, it should be done without altering its original stack-trace.
   Preferred way is of course to use "throw;" in the catch clause without specifying the exception, but otherwise ReflectHelper provides a way to preserve the stack-trace.
 * Otherwise it should be transmitted to the logger.

Some cases still do not follow this pattern for avoiding being too noisy, like "Try" utilities, failure in closing an already failed object, some "implemented by exception" features, ...
diff --git a/src/NHibernate/Async/Cache/StandardQueryCache.cs b/src/NHibernate/Async/Cache/StandardQueryCache.cs
@@ -115,14 +115,14 @@ public async Task<IList> GetAsync(QueryKey key, ICacheAssembler[] returnTypes, b
 						result.Add(await (TypeHelper.AssembleAsync((object[])cacheable[i], returnTypes, session, null, cancellationToken)).ConfigureAwait(false));
 					}
 				}
-				catch (UnresolvableObjectException)
+				catch (UnresolvableObjectException ex)
 				{
 					if (isNaturalKeyLookup)
 					{
 						//TODO: not really completely correct, since
 						//      the UnresolvableObjectException could occur while resolving
 						//      associations, leaving the PC in an inconsistent state
-						Log.Debug("could not reassemble cached result set");
+						Log.Debug(ex, "could not reassemble cached result set");
 						await (_queryCache.RemoveAsync(key, cancellationToken)).ConfigureAwait(false);
 						return null;
 					}
diff --git a/src/NHibernate/Async/Event/Default/DefaultMergeEventListener.cs b/src/NHibernate/Async/Event/Default/DefaultMergeEventListener.cs
@@ -263,11 +263,11 @@ private async Task<object> MergeTransientEntityAsync(object entity, string entit
 				
 				if (((EventCache)copyCache).IsOperatedOn(propertyFromEntity))
 				{
-					log.Info("property '{0}.{1}' from original entity is in copyCache and is in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);
+					log.Info(ex, "property '{0}.{1}' from original entity is in copyCache and is in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);
 				}
 				else
 				{
-					log.Info("property '{0}.{1}' from original entity is in copyCache and is not in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);
+					log.Info(ex, "property '{0}.{1}' from original entity is in copyCache and is not in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);
 				}
 				
 				// continue...; we'll find out if it ends up not getting saved later
diff --git a/src/NHibernate/Async/Impl/SessionFactoryImpl.cs b/src/NHibernate/Async/Impl/SessionFactoryImpl.cs
@@ -11,6 +11,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Data.Common;
 using System.Linq;
 using System.Runtime.Serialization;
diff --git a/src/NHibernate/Cache/StandardQueryCache.cs b/src/NHibernate/Cache/StandardQueryCache.cs
@@ -133,14 +133,14 @@ public IList Get(QueryKey key, ICacheAssembler[] returnTypes, bool isNaturalKeyL
 						result.Add(TypeHelper.Assemble((object[])cacheable[i], returnTypes, session, null));
 					}
 				}
-				catch (UnresolvableObjectException)
+				catch (UnresolvableObjectException ex)
 				{
 					if (isNaturalKeyLookup)
 					{
 						//TODO: not really completely correct, since
 						//      the UnresolvableObjectException could occur while resolving
 						//      associations, leaving the PC in an inconsistent state
-						Log.Debug("could not reassemble cached result set");
+						Log.Debug(ex, "could not reassemble cached result set");
 						_queryCache.Remove(key);
 						return null;
 					}
diff --git a/src/NHibernate/Cfg/SettingsFactory.cs b/src/NHibernate/Cfg/SettingsFactory.cs
@@ -62,9 +62,9 @@ public Settings BuildSettings(IDictionary<string, string> properties)
 			{
 				sqlExceptionConverter = SQLExceptionConverterFactory.BuildSQLExceptionConverter(dialect, properties);
 			}
-			catch (HibernateException)
+			catch (HibernateException he)
 			{
-				log.Warn("Error building SQLExceptionConverter; using minimal converter");
+				log.Warn(he, "Error building SQLExceptionConverter; using minimal converter");
 				sqlExceptionConverter = SQLExceptionConverterFactory.BuildMinimalSQLExceptionConverter();
 			}
 			settings.SqlExceptionConverter = sqlExceptionConverter;
diff --git a/src/NHibernate/Cfg/XmlHbmBinding/ClassBinder.cs b/src/NHibernate/Cfg/XmlHbmBinding/ClassBinder.cs
@@ -371,9 +371,9 @@ protected void BindAnyMeta(IAnyMapping anyMapping, Any model)
 					string entityName = GetClassName(metaValue.@class, mappings);
 					values[value] = entityName;
 				}
-				catch (InvalidCastException)
+				catch (InvalidCastException ice)
 				{
-					throw new MappingException("meta-type was not an IDiscriminatorType: " + metaType.Name);
+					throw new MappingException("meta-type was not an IDiscriminatorType: " + metaType.Name, ice);
 				}
 				catch (HibernateException he)
 				{
diff --git a/src/NHibernate/Collection/AbstractPersistentCollection.cs b/src/NHibernate/Collection/AbstractPersistentCollection.cs
@@ -61,9 +61,11 @@ public object Current
 						{
 							return enclosingInstance.operationQueue[position].AddedInstance;
 						}
-						catch (IndexOutOfRangeException)
+						catch (IndexOutOfRangeException ex)
 						{
-							throw new InvalidOperationException();
+							throw new InvalidOperationException(
+								"MoveNext as not been called or its last call has yielded false (meaning the enumerator is beyond the end of the enumeration).",
+								ex);
 						}
 					}
 				}
diff --git a/src/NHibernate/Engine/StatefulPersistenceContext.cs b/src/NHibernate/Engine/StatefulPersistenceContext.cs
@@ -1439,7 +1439,7 @@ void IDeserializationCallback.OnDeserialization(object sender)
 				}
 				catch (HibernateException he)
 				{
-					throw new InvalidOperationException(he.Message);
+					throw new InvalidOperationException(he.Message, he);
 				}
 			}
 
@@ -1467,7 +1467,7 @@ void IDeserializationCallback.OnDeserialization(object sender)
 				}
 				catch (MappingException me)
 				{
-					throw new InvalidOperationException(me.Message);
+					throw new InvalidOperationException(me.Message, me);
 				}
 			}
 		}
diff --git a/src/NHibernate/Event/Default/DefaultMergeEventListener.cs b/src/NHibernate/Event/Default/DefaultMergeEventListener.cs
@@ -266,11 +266,11 @@ private object MergeTransientEntity(object entity, string entityName, object req
 				
 				if (((EventCache)copyCache).IsOperatedOn(propertyFromEntity))
 				{
-					log.Info("property '{0}.{1}' from original entity is in copyCache and is in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);
+					log.Info(ex, "property '{0}.{1}' from original entity is in copyCache and is in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);
 				}
 				else
 				{
-					log.Info("property '{0}.{1}' from original entity is in copyCache and is not in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);
+					log.Info(ex, "property '{0}.{1}' from original entity is in copyCache and is not in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);
 				}
 				
 				// continue...; we'll find out if it ends up not getting saved later
diff --git a/src/NHibernate/Hql/Ast/ANTLR/HqlParser.cs b/src/NHibernate/Hql/Ast/ANTLR/HqlParser.cs
@@ -2,6 +2,7 @@
 using Antlr.Runtime;
 
 using NHibernate.Hql.Ast.ANTLR.Tree;
+using NHibernate.Util;
 using IToken = Antlr.Runtime.IToken;
 using RecognitionException = Antlr.Runtime.RecognitionException;
 
@@ -418,6 +419,7 @@ public IASTNode HandleIdentifierError(IToken token, RecognitionException ex)
 			}
 			
 			// Otherwise, handle the error normally.
+			ReflectHelper.PreserveStackTrace(ex);
 			throw ex;
 		}
 	}
diff --git a/src/NHibernate/Hql/Ast/ANTLR/HqlSqlWalker.cs b/src/NHibernate/Hql/Ast/ANTLR/HqlSqlWalker.cs
@@ -1097,7 +1097,7 @@ private void HandleWithFragment(FromElement fromElement, IASTNode hqlWithNode)
 			}
 			catch (Exception e)
 			{
-				throw new SemanticException(e.Message);
+				throw new SemanticException(e.Message, e);
 			}
 		}
 	}
diff --git a/src/NHibernate/Hql/Ast/ANTLR/QuerySyntaxException.cs b/src/NHibernate/Hql/Ast/ANTLR/QuerySyntaxException.cs
@@ -10,6 +10,7 @@ public class QuerySyntaxException : QueryException
 	{
 		protected QuerySyntaxException() {}
 		public QuerySyntaxException(string message, string hql) : base(message, hql) {}
+		public QuerySyntaxException(string message, string hql, Exception inner) : base(message, hql, inner) {}
 
 		public QuerySyntaxException(string message) : base(message) {}
 		public QuerySyntaxException(string message, Exception inner) : base(message, inner) {}
@@ -24,9 +25,9 @@ public static QuerySyntaxException Convert(RecognitionException e)
 		public static QuerySyntaxException Convert(RecognitionException e, string hql)
 		{
 			string positionInfo = e.Line > 0 && e.CharPositionInLine > 0
-			                      	? " near line " + e.Line + ", column " + e.CharPositionInLine
-			                      	: "";
-			return new QuerySyntaxException(e.Message + positionInfo, hql);
+				? " near line " + e.Line + ", column " + e.CharPositionInLine
+				: "";
+			return new QuerySyntaxException(e.Message + positionInfo, hql, e);
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Hql/Ast/ANTLR/QueryTranslatorImpl.cs b/src/NHibernate/Hql/Ast/ANTLR/QueryTranslatorImpl.cs
@@ -362,8 +362,6 @@ private void DoCompile(IDictionary<string, string> replacements, bool shallow, S
 			}
 			catch ( RecognitionException e ) 
 			{
-				// we do not actually propogate ANTLRExceptions as a cause, so
-				// log it here for diagnostic purposes
 				if ( log.IsInfoEnabled() ) 
 				{
 					log.Info(e, "converted antlr.RecognitionException");
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Tree/FromElement.cs b/src/NHibernate/Hql/Ast/ANTLR/Tree/FromElement.cs
@@ -544,11 +544,12 @@ public void HandlePropertyBeingDereferenced(IType propertySource, string propert
 						_dereferencedBySuperclassProperty = true;
 					}
 				}
-				catch (QueryException)
+				catch (QueryException ex)
 				{
 					// ignore it; the incoming property could not be found so we
 					// cannot be sure what to do here.  At the very least, the
 					// safest is to simply not apply any dereference toggling...
+					Log.Debug(ex, "Unable to find property {0}, no dereference will be handled for it.", propertyName);
 				}
 			}
 		}
diff --git a/src/NHibernate/Hql/Util/SessionFactoryHelper.cs b/src/NHibernate/Hql/Util/SessionFactoryHelper.cs
@@ -87,13 +87,13 @@ public IQueryableCollection GetCollectionPersister(String role)
 			{
 				return (IQueryableCollection)sfi.GetCollectionPersister(role);
 			}
-			catch (InvalidCastException)
+			catch (InvalidCastException ice)
 			{
-				throw new QueryException("collection is not queryable: " + role);
+				throw new QueryException("collection is not queryable: " + role, ice);
 			}
-			catch (Exception)
+			catch (Exception ex)
 			{
-				throw new QueryException("collection not found: " + role);
+				throw new QueryException("collection not found: " + role, ex);
 			}
 		}
 
@@ -186,15 +186,15 @@ public IQueryableCollection RequireQueryableCollection(String role)
 				}
 				return queryableCollection;
 			}
-			catch (InvalidCastException)
+			catch (InvalidCastException ice)
 			{
 				throw new QueryException(
-						"collection role is not queryable: " + role);
+						"collection role is not queryable: " + role, ice);
 			}
-			catch (Exception)
+			catch (Exception ex)
 			{
 				throw new QueryException("collection role not found: "
-						+ role);
+						+ role, ex);
 			}
 		}
 	}
diff --git a/src/NHibernate/Id/IdentifierGeneratorFactory.cs b/src/NHibernate/Id/IdentifierGeneratorFactory.cs
@@ -309,9 +309,9 @@ public static System.Type GetIdentifierGeneratorClass(string strategy, Dialect.D
 					clazz = ReflectHelper.ClassForName(strategy);
 				}
 			}
-			catch (Exception)
+			catch (Exception ex)
 			{
-				throw new IdentifierGenerationException("Could not interpret id generator strategy: " + strategy);
+				throw new IdentifierGenerationException("Could not interpret id generator strategy: " + strategy, ex);
 			}
 			return clazz;
 		}
diff --git a/src/NHibernate/Impl/SessionFactoryImpl.cs b/src/NHibernate/Impl/SessionFactoryImpl.cs
@@ -205,9 +205,10 @@ public SessionFactoryImpl(Configuration cfg, IMapping mapping, Settings settings
 					SchemaMetadataUpdater.QuoteTableAndColumns(cfg, Dialect);
 				}
 			}
-			catch (NotSupportedException)
+			catch (NotSupportedException ex)
 			{
-				// Ignore if the Dialect does not provide DataBaseSchema 
+				// Ignore if the Dialect does not provide DataBaseSchema
+				log.Warn(ex, "Dialect does not provide DataBaseSchema, but keywords import or auto quoting is enabled.");
 			}
 
 			#region Caches
@@ -339,9 +340,9 @@ public SessionFactoryImpl(Configuration cfg, IMapping mapping, Settings settings
 			{
 				uuid = (string)UuidGenerator.Generate(null, null);
 			}
-			catch (Exception)
+			catch (Exception ex)
 			{
-				throw new AssertionFailure("Could not generate UUID");
+				throw new AssertionFailure("Could not generate UUID", ex);
 			}
 
 			SessionFactoryObjectFactory.AddInstance(uuid, name, this, properties);
diff --git a/src/NHibernate/Mapping/Collection.cs b/src/NHibernate/Mapping/Collection.cs
@@ -154,9 +154,9 @@ public object Comparer
 					{
 						comparer = Cfg.Environment.BytecodeProvider.ObjectsFactory.CreateInstance(ReflectHelper.ClassForName(ComparerClassName));
 					}
-					catch
+					catch (Exception ex)
 					{
-						throw new MappingException("Could not instantiate comparator class [" + ComparerClassName + "] for collection " + Role);
+						throw new MappingException("Could not instantiate comparator class [" + ComparerClassName + "] for collection " + Role, ex);
 					}
 				}
 				return comparer;
diff --git a/src/NHibernate/Mapping/PersistentClass.cs b/src/NHibernate/Mapping/PersistentClass.cs
@@ -890,9 +890,9 @@ private Property GetRecursiveProperty(string propertyPath, IEnumerable<Property>
 					}
 				}
 			}
-			catch (MappingException)
+			catch (MappingException ex)
 			{
-				throw new MappingException("property [" + propertyPath + "] not found on entity [" + EntityName + "]");
+				throw new MappingException("property [" + propertyPath + "] not found on entity [" + EntityName + "]", ex);
 			}
 
 			return property;
diff --git a/src/NHibernate/Persister/Entity/AbstractEntityPersister.cs b/src/NHibernate/Persister/Entity/AbstractEntityPersister.cs
@@ -2206,14 +2206,14 @@ protected bool Check(int rows, object id, int tableNumber, IExpectation expectat
 			{
 				expectation.VerifyOutcomeNonBatched(rows, statement);
 			}
-			catch (StaleStateException)
+			catch (StaleStateException sse)
 			{
 				if (!IsNullableTable(tableNumber))
 				{
 					if (Factory.Statistics.IsStatisticsEnabled)
 						Factory.StatisticsImplementor.OptimisticFailure(EntityName);
 
-					throw new StaleObjectStateException(EntityName, id);
+					throw new StaleObjectStateException(EntityName, id, sse);
 				}
 			}
 			catch (TooManyRowsAffectedException ex)
diff --git a/src/NHibernate/QueryException.cs b/src/NHibernate/QueryException.cs
@@ -46,6 +46,21 @@ public QueryException(string message, string queryString) : base(message)
 			this.queryString = queryString;
 		}
 
+		/// <summary>
+		/// Initializes a new instance of the <see cref="QueryException"/> class.
+		/// </summary>
+		/// <param name="message">The message that describes the error. </param>
+		/// <param name="queryString">The query that contains the error.</param>
+		/// <param name="innerException">
+		/// The exception that is the cause of the current exception. If the innerException parameter
+		/// is not a null reference, the current exception is raised in a catch block that handles
+		/// the inner exception.
+		/// </param>
+		public QueryException(string message, string queryString, Exception innerException) : base(message, innerException)
+		{
+			this.queryString = queryString;
+		}
+
 		/// <summary>
 		/// Initializes a new instance of the <see cref="QueryException"/> class.
 		/// </summary>
diff --git a/src/NHibernate/StaleObjectStateException.cs b/src/NHibernate/StaleObjectStateException.cs
@@ -23,7 +23,17 @@ public class StaleObjectStateException : StaleStateException
 		/// <param name="entityName">The EntityName that NHibernate was trying to update in the database.</param>
 		/// <param name="identifier">The identifier of the object that is stale.</param>
 		public StaleObjectStateException(string entityName, object identifier)
-			: base("Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)")
+			: this(entityName, identifier, null)
+		{
+		}
+		/// <summary>
+		/// Initializes a new instance of the <see cref="StaleObjectStateException"/> class.
+		/// </summary>
+		/// <param name="entityName">The EntityName that NHibernate was trying to update in the database.</param>
+		/// <param name="identifier">The identifier of the object that is stale.</param>
+		/// <param name="innerException">The original exception having triggered this exception.</param>
+		public StaleObjectStateException(string entityName, object identifier, Exception innerException)
+			: base("Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)", innerException)
 		{
 			this.entityName = entityName;
 			this.identifier = identifier;
diff --git a/src/NHibernate/StaleStateException.cs b/src/NHibernate/StaleStateException.cs
@@ -9,10 +9,13 @@ public class StaleStateException : HibernateException
 		public StaleStateException(string message) : base(message)
 		{
 		}
+		public StaleStateException(string message, Exception innerException) : base(message, innerException)
+		{
+		}
 
 		protected StaleStateException(SerializationInfo info, StreamingContext context)
 			: base(info, context)
 		{
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Util/ReflectHelper.cs b/src/NHibernate/Util/ReflectHelper.cs

Original file line number	Diff line number	Diff line change
`@@ -115,14 +115,14 @@ public async Task<IList> GetAsync(QueryKey key, ICacheAssembler[] returnTypes, b`
`115`	`115`	`result.Add(await (TypeHelper.AssembleAsync((object[])cacheable[i], returnTypes, session, null, cancellationToken)).ConfigureAwait(false));`
`116`	`116`	`}`
`117`	`117`	`}`
`118`		`- catch (UnresolvableObjectException)`
	`118`	`+ catch (UnresolvableObjectException ex)`
`119`	`119`	`{`
`120`	`120`	`if (isNaturalKeyLookup)`
`121`	`121`	`{`
`122`	`122`	`//TODO: not really completely correct, since`
`123`	`123`	`// the UnresolvableObjectException could occur while resolving`
`124`	`124`	`// associations, leaving the PC in an inconsistent state`
`125`		`- Log.Debug("could not reassemble cached result set");`
	`125`	`+ Log.Debug(ex, "could not reassemble cached result set");`
`126`	`126`	`await (_queryCache.RemoveAsync(key, cancellationToken)).ConfigureAwait(false);`
`127`	`127`	`return null;`
`128`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -263,11 +263,11 @@ private async Task<object> MergeTransientEntityAsync(object entity, string entit`
`263`	`263`
`264`	`264`	`if (((EventCache)copyCache).IsOperatedOn(propertyFromEntity))`
`265`	`265`	`{`
`266`		`- log.Info("property '{0}.{1}' from original entity is in copyCache and is in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);`
	`266`	`+ log.Info(ex, "property '{0}.{1}' from original entity is in copyCache and is in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);`
`267`	`267`	`}`
`268`	`268`	`else`
`269`	`269`	`{`
`270`		`- log.Info("property '{0}.{1}' from original entity is in copyCache and is not in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);`
	`270`	`+ log.Info(ex, "property '{0}.{1}' from original entity is in copyCache and is not in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);`
`271`	`271`	`}`
`272`	`272`
`273`	`273`	`// continue...; we'll find out if it ends up not getting saved later`
Original file line number	Diff line number	Diff line change
`@@ -133,14 +133,14 @@ public IList Get(QueryKey key, ICacheAssembler[] returnTypes, bool isNaturalKeyL`
`133`	`133`	`result.Add(TypeHelper.Assemble((object[])cacheable[i], returnTypes, session, null));`
`134`	`134`	`}`
`135`	`135`	`}`
`136`		`- catch (UnresolvableObjectException)`
	`136`	`+ catch (UnresolvableObjectException ex)`
`137`	`137`	`{`
`138`	`138`	`if (isNaturalKeyLookup)`
`139`	`139`	`{`
`140`	`140`	`//TODO: not really completely correct, since`
`141`	`141`	`// the UnresolvableObjectException could occur while resolving`
`142`	`142`	`// associations, leaving the PC in an inconsistent state`
`143`		`- Log.Debug("could not reassemble cached result set");`
	`143`	`+ Log.Debug(ex, "could not reassemble cached result set");`
`144`	`144`	`_queryCache.Remove(key);`
`145`	`145`	`return null;`
`146`	`146`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,9 +62,9 @@ public Settings BuildSettings(IDictionary<string, string> properties)`
`62`	`62`	`{`
`63`	`63`	`sqlExceptionConverter = SQLExceptionConverterFactory.BuildSQLExceptionConverter(dialect, properties);`
`64`	`64`	`}`
`65`		`- catch (HibernateException)`
	`65`	`+ catch (HibernateException he)`
`66`	`66`	`{`
`67`		`- log.Warn("Error building SQLExceptionConverter; using minimal converter");`
	`67`	`+ log.Warn(he, "Error building SQLExceptionConverter; using minimal converter");`
`68`	`68`	`sqlExceptionConverter = SQLExceptionConverterFactory.BuildMinimalSQLExceptionConverter();`
`69`	`69`	`}`
`70`	`70`	`settings.SqlExceptionConverter = sqlExceptionConverter;`
Original file line number	Diff line number	Diff line change
`@@ -371,9 +371,9 @@ protected void BindAnyMeta(IAnyMapping anyMapping, Any model)`
`371`	`371`	`string entityName = GetClassName(metaValue.@class, mappings);`
`372`	`372`	`values[value] = entityName;`
`373`	`373`	`}`
`374`		`- catch (InvalidCastException)`
	`374`	`+ catch (InvalidCastException ice)`
`375`	`375`	`{`
`376`		`- throw new MappingException("meta-type was not an IDiscriminatorType: " + metaType.Name);`
	`376`	`+ throw new MappingException("meta-type was not an IDiscriminatorType: " + metaType.Name, ice);`
`377`	`377`	`}`
`378`	`378`	`catch (HibernateException he)`
`379`	`379`	`{`
Original file line number	Diff line number	Diff line change
`@@ -61,9 +61,11 @@ public object Current`
`61`	`61`	`{`
`62`	`62`	`return enclosingInstance.operationQueue[position].AddedInstance;`
`63`	`63`	`}`
`64`		`- catch (IndexOutOfRangeException)`
	`64`	`+ catch (IndexOutOfRangeException ex)`
`65`	`65`	`{`
`66`		`- throw new InvalidOperationException();`
	`66`	`+ throw new InvalidOperationException(`
	`67`	`+ "MoveNext as not been called or its last call has yielded false (meaning the enumerator is beyond the end of the enumeration).",`
	`68`	`+ ex);`
`67`	`69`	`}`
`68`	`70`	`}`
`69`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1439,7 +1439,7 @@ void IDeserializationCallback.OnDeserialization(object sender)`
`1439`	`1439`	`}`
`1440`	`1440`	`catch (HibernateException he)`
`1441`	`1441`	`{`
`1442`		`- throw new InvalidOperationException(he.Message);`
	`1442`	`+ throw new InvalidOperationException(he.Message, he);`
`1443`	`1443`	`}`
`1444`	`1444`	`}`
`1445`	`1445`
`@@ -1467,7 +1467,7 @@ void IDeserializationCallback.OnDeserialization(object sender)`
`1467`	`1467`	`}`
`1468`	`1468`	`catch (MappingException me)`
`1469`	`1469`	`{`
`1470`		`- throw new InvalidOperationException(me.Message);`
	`1470`	`+ throw new InvalidOperationException(me.Message, me);`
`1471`	`1471`	`}`
`1472`	`1472`	`}`
`1473`	`1473`	`}`
Original file line number	Diff line number	Diff line change
`@@ -266,11 +266,11 @@ private object MergeTransientEntity(object entity, string entityName, object req`
`266`	`266`
`267`	`267`	`if (((EventCache)copyCache).IsOperatedOn(propertyFromEntity))`
`268`	`268`	`{`
`269`		`- log.Info("property '{0}.{1}' from original entity is in copyCache and is in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);`
	`269`	`+ log.Info(ex, "property '{0}.{1}' from original entity is in copyCache and is in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);`
`270`	`270`	`}`
`271`	`271`	`else`
`272`	`272`	`{`
`273`		`- log.Info("property '{0}.{1}' from original entity is in copyCache and is not in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);`
	`273`	`+ log.Info(ex, "property '{0}.{1}' from original entity is in copyCache and is not in the process of being merged; {1} =[{2}]", copyEntry.EntityName, propertyName, propertyFromEntity);`
`274`	`274`	`}`
`275`	`275`
`276`	`276`	`// continue...; we'll find out if it ends up not getting saved later`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using Antlr.Runtime;`
`3`	`3`
`4`	`4`	`using NHibernate.Hql.Ast.ANTLR.Tree;`
	`5`	`+using NHibernate.Util;`
`5`	`6`	`using IToken = Antlr.Runtime.IToken;`
`6`	`7`	`using RecognitionException = Antlr.Runtime.RecognitionException;`
`7`	`8`
`@@ -418,6 +419,7 @@ public IASTNode HandleIdentifierError(IToken token, RecognitionException ex)`
`418`	`419`	`}`
`419`	`420`
`420`	`421`	`// Otherwise, handle the error normally.`
	`422`	`+ ReflectHelper.PreserveStackTrace(ex);`
`421`	`423`	`throw ex;`
`422`	`424`	`}`
`423`	`425`	`}`