Use generic CollectingNodeVisitor in hql parser (#2039)

bahusoid · fredericDelaporte · commit bf1e11647e63 · 2019-03-21T23:08:48.000+01:00
diff --git a/src/NHibernate/Hql/Ast/ANTLR/HqlSqlWalker.cs b/src/NHibernate/Hql/Ast/ANTLR/HqlSqlWalker.cs
@@ -390,7 +390,7 @@ private void PostProcessDML(IRestrictableStatement statement)
 		{
 			statement.FromClause.Resolve();
 
-			var fromElement = (FromElement)statement.FromClause.GetFromElements()[0];
+			var fromElement = statement.FromClause.GetFromElementsTyped()[0];
 			IQueryable persister = fromElement.Queryable;
 			// Make #@%$^#^&# sure no alias is applied to the table name
 			fromElement.Text = persister.TableName;
@@ -495,7 +495,7 @@ void ProcessQuery(IASTNode select, IASTNode query)
 				joinProcessor.ProcessJoins(rs);
 
 				// Attach any mapping-defined "ORDER BY" fragments
-				foreach (FromElement fromElement in qn.FromClause.GetProjectionList())
+				foreach (FromElement fromElement in qn.FromClause.GetProjectionListTyped())
 				{
 					if ( fromElement.IsFetch && fromElement.QueryableCollection != null ) 
 					{
@@ -588,7 +588,7 @@ void BeforeSelectClause()
 			// Turn off includeSubclasses on all FromElements.
 			FromClause from = CurrentFromClause;
 
-			foreach (FromElement fromElement in from.GetFromElements())
+			foreach (FromElement fromElement in from.GetFromElementsTyped())
 			{
 				fromElement.IncludeSubclasses = false;
 			}
@@ -966,10 +966,10 @@ bool IsNonQualifiedPropertyRef(IASTNode ident)
 				return false;
 			}
 
-			IList<IASTNode> fromElements = _currentFromClause.GetExplicitFromElements();
-			if ( fromElements.Count == 1 ) 
+			var fromElements = _currentFromClause.GetExplicitFromElementsTyped();
+			if ( fromElements.Count == 1 )
 			{
-				FromElement fromElement = (FromElement) fromElements[0];
+				FromElement fromElement = fromElements[0];
 
 				log.Info("attempting to resolve property [{0}] as a non-qualified ref", identText);
 
@@ -982,7 +982,7 @@ bool IsNonQualifiedPropertyRef(IASTNode ident)
 
 		IASTNode LookupNonQualifiedProperty(IASTNode property)
 		{
-			FromElement fromElement = (FromElement) _currentFromClause.GetExplicitFromElements()[0];
+			FromElement fromElement = _currentFromClause.GetExplicitFromElementsTyped()[0];
 			IASTNode syntheticDotNode = GenerateSyntheticDotNodeForNonQualifiedPropertyRef( property, fromElement );
 			return LookupProperty( syntheticDotNode, false, _currentClauseType == SELECT );
 		}
diff --git a/src/NHibernate/Hql/Ast/ANTLR/QueryTranslatorImpl.cs b/src/NHibernate/Hql/Ast/ANTLR/QueryTranslatorImpl.cs
@@ -285,8 +285,8 @@ public bool ContainsCollectionFetches
 			get
 			{
 				ErrorIfDML();
-				IList<IASTNode> collectionFetches = ((QueryNode)_sqlAst).FromClause.GetCollectionFetches();
-				return collectionFetches != null && collectionFetches.Count > 0;
+				var collectionFetches = ((QueryNode)_sqlAst).FromClause.GetCollectionFetchesTyped();
+				return collectionFetches.Count > 0;
 			}
 		}
 
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Tree/AssignmentSpecification.cs b/src/NHibernate/Hql/Ast/ANTLR/Tree/AssignmentSpecification.cs
@@ -75,7 +75,7 @@ public AssignmentSpecification(IASTNode eq, IQueryable persister)
 			}
 			else
 			{
-				var parameterList = ASTUtil.CollectChildren(rhs, IsParam);
+				var parameterList = ASTUtil.CollectChildren<ParameterNode>(rhs, IsParam);
 				_hqlParameters = new IParameterSpecification[parameterList.Count];
 				int i = 0;
 				foreach (ParameterNode parameterNode in parameterList)
@@ -150,4 +150,4 @@ public SqlString SqlAssignmentFragment
 
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Tree/FromClause.cs b/src/NHibernate/Hql/Ast/ANTLR/Tree/FromClause.cs
@@ -72,15 +72,27 @@ public FromClause ParentFromClause
 		{
 			get { return _parentFromClause; }
 		}
-
+		
+		//6.0 TODO: Replace with Typed version below
 		public IList<IASTNode> GetExplicitFromElements()
 		{
-			return ASTUtil.CollectChildren(this, ExplicitFromPredicate);
+			return ASTUtil.CollectChildren<IASTNode>(this, ExplicitFromPredicate);
 		}
-
+		
+		internal IList<FromElement> GetExplicitFromElementsTyped()
+		{
+			return ASTUtil.CollectChildren<FromElement>(this, ExplicitFromPredicate);
+		}
+		
+		//6.0 TODO: Replace with Typed version below
 		public IList<IASTNode> GetCollectionFetches()
 		{
-			return ASTUtil.CollectChildren(this, CollectionFetchPredicate);
+			return ASTUtil.CollectChildren<IASTNode>(this, CollectionFetchPredicate);
+		}
+
+		internal IList<FromElement> GetCollectionFetchesTyped()
+		{
+			return ASTUtil.CollectChildren<FromElement>(this, CollectionFetchPredicate);
 		}
 
 		public FromElement FindCollectionJoin(String path)
@@ -198,27 +210,39 @@ public FromElement GetFromElement(string aliasOrClassName)
 			return fromElement;
 		}
 
+		//6.0 TODO: Replace with Typed version below
 		/// <summary>
 		/// Returns the list of from elements in order.
 		/// </summary>
 		/// <returns>The list of from elements (instances of FromElement).</returns>
 		public IList<IASTNode> GetFromElements()
 		{
-			return ASTUtil.CollectChildren(this, FromElementPredicate);
+			return ASTUtil.CollectChildren<IASTNode>(this, FromElementPredicate);
 		}
 
+		internal IList<FromElement> GetFromElementsTyped()
+		{
+			return ASTUtil.CollectChildren<FromElement>(this, FromElementPredicate);
+		}
+
+		//6.0 TODO: Replace with Typed version below
 		/// <summary>
 		/// Returns the list of from elements that will be part of the result set.
 		/// </summary>
 		/// <returns>the list of from elements that will be part of the result set.</returns>
 		public IList<IASTNode> GetProjectionList()
 		{
-			return ASTUtil.CollectChildren(this, ProjectionListPredicate);
+			return ASTUtil.CollectChildren<IASTNode>(this, ProjectionListPredicate);
+		}
+
+		internal IList<FromElement> GetProjectionListTyped()
+		{
+			return ASTUtil.CollectChildren<FromElement>(this, ProjectionListPredicate);
 		}
 
 		public FromElement GetFromElement()
 		{
-			return (FromElement)GetFromElements()[0];
+			return GetFromElementsTyped()[0];
 		}
 
 		public void AddDuplicateAlias(string alias, FromElement element)
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Tree/IdentNode.cs b/src/NHibernate/Hql/Ast/ANTLR/Tree/IdentNode.cs
@@ -314,14 +314,14 @@ private IType GetNakedPropertyType(FromElement fromElement)
 
 		private FromElement LocateSingleFromElement()
 		{
-			IList<IASTNode> fromElements = Walker.CurrentFromClause.GetFromElements();
+			var fromElements = Walker.CurrentFromClause.GetFromElementsTyped();
 			if (fromElements == null || fromElements.Count != 1)
 			{
 				// TODO : should this be an error?
 				return null;
 			}
 
-			FromElement element = (FromElement)fromElements[0];
+			FromElement element = fromElements[0];
 			if (element.ClassAlias != null)
 			{
 				// naked property-refs cannot be used with an aliased from element
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Tree/SelectClause.cs b/src/NHibernate/Hql/Ast/ANTLR/Tree/SelectClause.cs
@@ -51,7 +51,7 @@ public void InitializeDerivedSelectClause(FromClause fromClause)
 			//			// NOTE : the isSubQuery() bit is a temporary hack...
 			//			throw new QuerySyntaxException( "JPA-QL compliance requires select clause" );
 			//		}
-			IList<IASTNode> fromElements = fromClause.GetProjectionList();
+			var fromElements = fromClause.GetProjectionListTyped();
 
 			ASTAppender appender = new ASTAppender(ASTFactory, this);	// Get ready to start adding nodes.
 			int size = fromElements.Count;
@@ -182,7 +182,7 @@ public void InitializeExplicitSelectClause(FromClause fromClause)
 			if (!Walker.IsShallowQuery)
 			{
 				// add the fetched entities
-				IList<IASTNode> fromElements = fromClause.GetProjectionList();
+				var fromElements = fromClause.GetProjectionListTyped();
 
 				ASTAppender appender = new ASTAppender(ASTFactory, this);	// Get ready to start adding nodes.
 				int size = fromElements.Count;
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Util/ASTUtil.cs b/src/NHibernate/Hql/Ast/ANTLR/Util/ASTUtil.cs
@@ -99,9 +99,16 @@ public static IASTNode FindTypeInChildren(IASTNode parent, int type)
 			return null;
 		}
 
+		//Since 5.3
+		[Obsolete("Use generic version instead")]
 		public static IList<IASTNode> CollectChildren(IASTNode root, FilterPredicate predicate)
 		{
-			return new CollectingNodeVisitor(predicate).Collect(root);
+			return new CollectingNodeVisitor<IASTNode>(predicate).Collect(root);
+		}
+
+		public static IList<TNode> CollectChildren<TNode>(IASTNode root, FilterPredicate predicate) where TNode : IASTNode
+		{
+			return new CollectingNodeVisitor<TNode>(predicate).Collect(root);
 		}
 
 		/// <summary>
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Util/CollectingNodeVisitor.cs b/src/NHibernate/Hql/Ast/ANTLR/Util/CollectingNodeVisitor.cs
@@ -12,10 +12,20 @@ namespace NHibernate.Hql.Ast.ANTLR.Util
 	[CLSCompliant(false)]
 	public delegate bool FilterPredicate(IASTNode node);
 
+	//Since 5.3
+	[Obsolete("Use generic version instead")]
 	[CLSCompliant(false)]
-	public class CollectingNodeVisitor : IVisitationStrategy
+	public class CollectingNodeVisitor : CollectingNodeVisitor<IASTNode>
 	{
-		private readonly List<IASTNode> collectedNodes = new List<IASTNode>();
+		public CollectingNodeVisitor(FilterPredicate predicate) : base(predicate)
+		{
+		}
+	}
+
+	[CLSCompliant(false)]
+	public class CollectingNodeVisitor<TNode> : IVisitationStrategy 
+	{
+		private readonly List<TNode> collectedNodes = new List<TNode>();
 		private readonly FilterPredicate predicate;
 
 		public CollectingNodeVisitor(FilterPredicate predicate)
@@ -29,17 +39,17 @@ public void Visit(IASTNode node)
 		{
 			if (predicate == null || predicate(node))
 			{
-				collectedNodes.Add(node);
+				collectedNodes.Add((TNode) node);
 			}
 		}
 
 		#endregion
 
-		public IList<IASTNode> Collect(IASTNode root)
+		public IList<TNode> Collect(IASTNode root)
 		{
 			var traverser = new NodeTraverser(this);
 			traverser.TraverseDepthFirst(root);
 			return collectedNodes;
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Util/JoinProcessor.cs b/src/NHibernate/Hql/Ast/ANTLR/Util/JoinProcessor.cs
@@ -1,16 +1,8 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
 using NHibernate.Engine;
 using NHibernate.Hql.Ast.ANTLR.Tree;
-using NHibernate.Impl;
-using NHibernate.Param;
 using NHibernate.SqlCommand;
-using NHibernate.Type;
-using NHibernate.Util;
 
 namespace NHibernate.Hql.Ast.ANTLR.Util
 {
@@ -74,7 +66,7 @@ public void ProcessJoins(IRestrictableStatement query)
 			FromClause fromClause = query.FromClause;
 			var supportRootAlias = !(query is DeleteStatement || query is UpdateStatement);
 
-			IList<IASTNode> fromElements;
+			IList<FromElement> fromElements;
 			if ( DotNode.UseThetaStyleImplicitJoins ) 
 			{
 				// for regression testing against output from the old parser...
@@ -83,8 +75,8 @@ public void ProcessJoins(IRestrictableStatement query)
 				// expected by the old parser; this is definitely another of those "only needed
 				// for regression purposes".  The SyntheticAndFactory, then, simply injects them as it
 				// encounters them.
-				fromElements = new List<IASTNode>();
-				IList<IASTNode> t = fromClause.GetFromElements();
+				fromElements = new List<FromElement>();
+				var t = fromClause.GetFromElementsTyped();
 
 				for (int i = t.Count - 1; i >= 0; i--)
 				{
@@ -93,7 +85,7 @@ public void ProcessJoins(IRestrictableStatement query)
 			}
 			else 
 			{
-				fromElements = fromClause.GetFromElements();
+				fromElements = fromClause.GetFromElementsTyped();
 			}
 
 			// Iterate through the alias,JoinSequence pairs and generate SQL token nodes.

Original file line number	Diff line number	Diff line change
`@@ -390,7 +390,7 @@ private void PostProcessDML(IRestrictableStatement statement)`
`390`	`390`	`{`
`391`	`391`	`statement.FromClause.Resolve();`
`392`	`392`
`393`		`- var fromElement = (FromElement)statement.FromClause.GetFromElements()[0];`
	`393`	`+ var fromElement = statement.FromClause.GetFromElementsTyped()[0];`
`394`	`394`	`IQueryable persister = fromElement.Queryable;`
`395`	`395`	`// Make #@%$^#^&# sure no alias is applied to the table name`
`396`	`396`	`fromElement.Text = persister.TableName;`
`@@ -495,7 +495,7 @@ void ProcessQuery(IASTNode select, IASTNode query)`
`495`	`495`	`joinProcessor.ProcessJoins(rs);`
`496`	`496`
`497`	`497`	`// Attach any mapping-defined "ORDER BY" fragments`
`498`		`- foreach (FromElement fromElement in qn.FromClause.GetProjectionList())`
	`498`	`+ foreach (FromElement fromElement in qn.FromClause.GetProjectionListTyped())`
`499`	`499`	`{`
`500`	`500`	`if ( fromElement.IsFetch && fromElement.QueryableCollection != null )`
`501`	`501`	`{`
`@@ -588,7 +588,7 @@ void BeforeSelectClause()`
`588`	`588`	`// Turn off includeSubclasses on all FromElements.`
`589`	`589`	`FromClause from = CurrentFromClause;`
`590`	`590`
`591`		`- foreach (FromElement fromElement in from.GetFromElements())`
	`591`	`+ foreach (FromElement fromElement in from.GetFromElementsTyped())`
`592`	`592`	`{`
`593`	`593`	`fromElement.IncludeSubclasses = false;`
`594`	`594`	`}`
`@@ -966,10 +966,10 @@ bool IsNonQualifiedPropertyRef(IASTNode ident)`
`966`	`966`	`return false;`
`967`	`967`	`}`
`968`	`968`
`969`		`- IList<IASTNode> fromElements = _currentFromClause.GetExplicitFromElements();`
`970`		`- if ( fromElements.Count == 1 )`
	`969`	`+ var fromElements = _currentFromClause.GetExplicitFromElementsTyped();`
	`970`	`+ if ( fromElements.Count == 1 )`
`971`	`971`	`{`
`972`		`- FromElement fromElement = (FromElement) fromElements[0];`
	`972`	`+ FromElement fromElement = fromElements[0];`
`973`	`973`
`974`	`974`	`log.Info("attempting to resolve property [{0}] as a non-qualified ref", identText);`
`975`	`975`
`@@ -982,7 +982,7 @@ bool IsNonQualifiedPropertyRef(IASTNode ident)`
`982`	`982`
`983`	`983`	`IASTNode LookupNonQualifiedProperty(IASTNode property)`
`984`	`984`	`{`
`985`		`- FromElement fromElement = (FromElement) _currentFromClause.GetExplicitFromElements()[0];`
	`985`	`+ FromElement fromElement = _currentFromClause.GetExplicitFromElementsTyped()[0];`
`986`	`986`	`IASTNode syntheticDotNode = GenerateSyntheticDotNodeForNonQualifiedPropertyRef( property, fromElement );`
`987`	`987`	`return LookupProperty( syntheticDotNode, false, _currentClauseType == SELECT );`
`988`	`988`	`}`
Original file line number	Diff line number	Diff line change
`@@ -285,8 +285,8 @@ public bool ContainsCollectionFetches`
`285`	`285`	`get`
`286`	`286`	`{`
`287`	`287`	`ErrorIfDML();`
`288`		`- IList<IASTNode> collectionFetches = ((QueryNode)_sqlAst).FromClause.GetCollectionFetches();`
`289`		`- return collectionFetches != null && collectionFetches.Count > 0;`
	`288`	`+ var collectionFetches = ((QueryNode)_sqlAst).FromClause.GetCollectionFetchesTyped();`
	`289`	`+ return collectionFetches.Count > 0;`
`290`	`290`	`}`
`291`	`291`	`}`
`292`	`292`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public AssignmentSpecification(IASTNode eq, IQueryable persister)`
`75`	`75`	`}`
`76`	`76`	`else`
`77`	`77`	`{`
`78`		`- var parameterList = ASTUtil.CollectChildren(rhs, IsParam);`
	`78`	`+ var parameterList = ASTUtil.CollectChildren<ParameterNode>(rhs, IsParam);`
`79`	`79`	`_hqlParameters = new IParameterSpecification[parameterList.Count];`
`80`	`80`	`int i = 0;`
`81`	`81`	`foreach (ParameterNode parameterNode in parameterList)`
`@@ -150,4 +150,4 @@ public SqlString SqlAssignmentFragment`
`150`	`150`
`151`	`151`	`}`
`152`	`152`	`}`
`153`		`-}`
	`153`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -72,15 +72,27 @@ public FromClause ParentFromClause`
`72`	`72`	`{`
`73`	`73`	`get { return _parentFromClause; }`
`74`	`74`	`}`
`75`		`-`
	`75`	`+`
	`76`	`+ //6.0 TODO: Replace with Typed version below`
`76`	`77`	`public IList<IASTNode> GetExplicitFromElements()`
`77`	`78`	`{`
`78`		`- return ASTUtil.CollectChildren(this, ExplicitFromPredicate);`
	`79`	`+ return ASTUtil.CollectChildren<IASTNode>(this, ExplicitFromPredicate);`
`79`	`80`	`}`
`80`		`-`
	`81`	`+`
	`82`	`+ internal IList<FromElement> GetExplicitFromElementsTyped()`
	`83`	`+ {`
	`84`	`+ return ASTUtil.CollectChildren<FromElement>(this, ExplicitFromPredicate);`
	`85`	`+ }`
	`86`	`+`
	`87`	`+ //6.0 TODO: Replace with Typed version below`
`81`	`88`	`public IList<IASTNode> GetCollectionFetches()`
`82`	`89`	`{`
`83`		`- return ASTUtil.CollectChildren(this, CollectionFetchPredicate);`
	`90`	`+ return ASTUtil.CollectChildren<IASTNode>(this, CollectionFetchPredicate);`
	`91`	`+ }`
	`92`	`+`
	`93`	`+ internal IList<FromElement> GetCollectionFetchesTyped()`
	`94`	`+ {`
	`95`	`+ return ASTUtil.CollectChildren<FromElement>(this, CollectionFetchPredicate);`
`84`	`96`	`}`
`85`	`97`
`86`	`98`	`public FromElement FindCollectionJoin(String path)`
`@@ -198,27 +210,39 @@ public FromElement GetFromElement(string aliasOrClassName)`
`198`	`210`	`return fromElement;`
`199`	`211`	`}`
`200`	`212`
	`213`	`+ //6.0 TODO: Replace with Typed version below`
`201`	`214`	`/// <summary>`
`202`	`215`	`/// Returns the list of from elements in order.`
`203`	`216`	`/// </summary>`
`204`	`217`	`/// <returns>The list of from elements (instances of FromElement).</returns>`
`205`	`218`	`public IList<IASTNode> GetFromElements()`
`206`	`219`	`{`
`207`		`- return ASTUtil.CollectChildren(this, FromElementPredicate);`
	`220`	`+ return ASTUtil.CollectChildren<IASTNode>(this, FromElementPredicate);`
`208`	`221`	`}`
`209`	`222`
	`223`	`+ internal IList<FromElement> GetFromElementsTyped()`
	`224`	`+ {`
	`225`	`+ return ASTUtil.CollectChildren<FromElement>(this, FromElementPredicate);`
	`226`	`+ }`
	`227`	`+`
	`228`	`+ //6.0 TODO: Replace with Typed version below`
`210`	`229`	`/// <summary>`
`211`	`230`	`/// Returns the list of from elements that will be part of the result set.`
`212`	`231`	`/// </summary>`
`213`	`232`	`/// <returns>the list of from elements that will be part of the result set.</returns>`
`214`	`233`	`public IList<IASTNode> GetProjectionList()`
`215`	`234`	`{`
`216`		`- return ASTUtil.CollectChildren(this, ProjectionListPredicate);`
	`235`	`+ return ASTUtil.CollectChildren<IASTNode>(this, ProjectionListPredicate);`
	`236`	`+ }`
	`237`	`+`
	`238`	`+ internal IList<FromElement> GetProjectionListTyped()`
	`239`	`+ {`
	`240`	`+ return ASTUtil.CollectChildren<FromElement>(this, ProjectionListPredicate);`
`217`	`241`	`}`
`218`	`242`
`219`	`243`	`public FromElement GetFromElement()`
`220`	`244`	`{`
`221`		`- return (FromElement)GetFromElements()[0];`
	`245`	`+ return GetFromElementsTyped()[0];`
`222`	`246`	`}`
`223`	`247`
`224`	`248`	`public void AddDuplicateAlias(string alias, FromElement element)`
Original file line number	Diff line number	Diff line change
`@@ -314,14 +314,14 @@ private IType GetNakedPropertyType(FromElement fromElement)`
`314`	`314`
`315`	`315`	`private FromElement LocateSingleFromElement()`
`316`	`316`	`{`
`317`		`- IList<IASTNode> fromElements = Walker.CurrentFromClause.GetFromElements();`
	`317`	`+ var fromElements = Walker.CurrentFromClause.GetFromElementsTyped();`
`318`	`318`	`if (fromElements == null \|\| fromElements.Count != 1)`
`319`	`319`	`{`
`320`	`320`	`// TODO : should this be an error?`
`321`	`321`	`return null;`
`322`	`322`	`}`
`323`	`323`
`324`		`- FromElement element = (FromElement)fromElements[0];`
	`324`	`+ FromElement element = fromElements[0];`
`325`	`325`	`if (element.ClassAlias != null)`
`326`	`326`	`{`
`327`	`327`	`// naked property-refs cannot be used with an aliased from element`
Original file line number	Diff line number	Diff line change
`@@ -99,9 +99,16 @@ public static IASTNode FindTypeInChildren(IASTNode parent, int type)`
`99`	`99`	`return null;`
`100`	`100`	`}`
`101`	`101`
	`102`	`+ //Since 5.3`
	`103`	`+ [Obsolete("Use generic version instead")]`
`102`	`104`	`public static IList<IASTNode> CollectChildren(IASTNode root, FilterPredicate predicate)`
`103`	`105`	`{`
`104`		`- return new CollectingNodeVisitor(predicate).Collect(root);`
	`106`	`+ return new CollectingNodeVisitor<IASTNode>(predicate).Collect(root);`
	`107`	`+ }`
	`108`	`+`
	`109`	`+ public static IList<TNode> CollectChildren<TNode>(IASTNode root, FilterPredicate predicate) where TNode : IASTNode`
	`110`	`+ {`
	`111`	`+ return new CollectingNodeVisitor<TNode>(predicate).Collect(root);`
`105`	`112`	`}`
`106`	`113`
`107`	`114`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -12,10 +12,20 @@ namespace NHibernate.Hql.Ast.ANTLR.Util`
`12`	`12`	`[CLSCompliant(false)]`
`13`	`13`	`public delegate bool FilterPredicate(IASTNode node);`
`14`	`14`
	`15`	`+ //Since 5.3`
	`16`	`+ [Obsolete("Use generic version instead")]`
`15`	`17`	`[CLSCompliant(false)]`
`16`		`- public class CollectingNodeVisitor : IVisitationStrategy`
	`18`	`+ public class CollectingNodeVisitor : CollectingNodeVisitor<IASTNode>`
`17`	`19`	`{`
`18`		`- private readonly List<IASTNode> collectedNodes = new List<IASTNode>();`
	`20`	`+ public CollectingNodeVisitor(FilterPredicate predicate) : base(predicate)`
	`21`	`+ {`
	`22`	`+ }`
	`23`	`+ }`
	`24`	`+`
	`25`	`+ [CLSCompliant(false)]`
	`26`	`+ public class CollectingNodeVisitor<TNode> : IVisitationStrategy`
	`27`	`+ {`
	`28`	`+ private readonly List<TNode> collectedNodes = new List<TNode>();`
`19`	`29`	`private readonly FilterPredicate predicate;`
`20`	`30`
`21`	`31`	`public CollectingNodeVisitor(FilterPredicate predicate)`
`@@ -29,17 +39,17 @@ public void Visit(IASTNode node)`
`29`	`39`	`{`
`30`	`40`	`if (predicate == null \|\| predicate(node))`
`31`	`41`	`{`
`32`		`- collectedNodes.Add(node);`
	`42`	`+ collectedNodes.Add((TNode) node);`
`33`	`43`	`}`
`34`	`44`	`}`
`35`	`45`
`36`	`46`	`#endregion`
`37`	`47`
`38`		`- public IList<IASTNode> Collect(IASTNode root)`
	`48`	`+ public IList<TNode> Collect(IASTNode root)`
`39`	`49`	`{`
`40`	`50`	`var traverser = new NodeTraverser(this);`
`41`	`51`	`traverser.TraverseDepthFirst(root);`
`42`	`52`	`return collectedNodes;`
`43`	`53`	`}`
`44`	`54`	`}`
`45`		`-}`
	`55`	`+}`