Replace usage of non-generic IEnumerable in ConventionVisitor (#686)

hazzik · web-flow · commit e18953782df0 · 2024-05-08T06:21:15.000+02:00
+semver:patch
diff --git a/src/FluentNHibernate/Conventions/IConvention.cs b/src/FluentNHibernate/Conventions/IConvention.cs
@@ -25,8 +25,7 @@ public interface IConventionAcceptance<TInspector>
 /// </summary>
 /// <typeparam name="TInspector">Inspector instance for use in retrieving values and setting expectations</typeparam>
 /// <typeparam name="TInstance">Apply instance</typeparam>
-public interface IConvention<TInspector, TInstance>
-    : IConvention
+public interface IConvention<TInspector, TInstance> : IConvention
     where TInspector : IInspector
     where TInstance : TInspector
 {
diff --git a/src/FluentNHibernate/Visitors/ConventionVisitor.cs b/src/FluentNHibernate/Visitors/ConventionVisitor.cs
@@ -15,13 +15,13 @@ namespace FluentNHibernate.Visitors;
 
 public class ConventionVisitor : DefaultMappingModelVisitor
 {
-    readonly Dictionary<Collection, Action<MappingModel.Collections.CollectionMapping>> collections;
+    readonly Dictionary<Collection, Action<CollectionMapping>> collections;
     readonly IConventionFinder finder;
     Type currentType;
 
     public ConventionVisitor(IConventionFinder finder)
     {
-        collections = new Dictionary<Collection, Action<MappingModel.Collections.CollectionMapping>>
+        collections = new Dictionary<Collection, Action<CollectionMapping>>
         {
             { Collection.Array, ProcessArray },
             { Collection.Bag, ProcessBag },
@@ -36,24 +36,21 @@ public override void ProcessHibernateMapping(HibernateMapping hibernateMapping)
     {
         var conventions = finder.Find<IHibernateMappingConvention>();
 
-        Apply<IHibernateMappingInspector, IHibernateMappingInstance>(conventions,
-            new HibernateMappingInstance(hibernateMapping));
+        Apply(conventions, new HibernateMappingInstance(hibernateMapping));
     }
 
     public override void ProcessId(IdMapping idMapping)
     {
         var conventions = finder.Find<IIdConvention>();
 
-        Apply<IIdentityInspector, IIdentityInstance>(conventions,
-            new IdentityInstance(idMapping));
+        Apply(conventions, new IdentityInstance(idMapping));
     }
 
     public override void ProcessCompositeId(CompositeIdMapping idMapping)
     {
         var conventions = finder.Find<ICompositeIdentityConvention>();
 
-        Apply<ICompositeIdentityInspector, ICompositeIdentityInstance>(conventions,
-            new CompositeIdentityInstance(idMapping));
+        Apply(conventions, new CompositeIdentityInstance(idMapping));
     }
 
     public override void ProcessClass(ClassMapping classMapping)
@@ -62,46 +59,40 @@ public override void ProcessClass(ClassMapping classMapping)
 
         currentType = classMapping.Type;
 
-        Apply<IClassInspector, IClassInstance>(conventions,
-            new ClassInstance(classMapping));
+        Apply(conventions, new ClassInstance(classMapping));
     }
 
     public override void ProcessProperty(PropertyMapping propertyMapping)
     {
         var conventions = finder.Find<IPropertyConvention>();
 
-        Apply<IPropertyInspector, IPropertyInstance>(conventions,
-            new PropertyInstance(propertyMapping));
+        Apply(conventions, new PropertyInstance(propertyMapping));
     }
 
     public override void ProcessColumn(ColumnMapping columnMapping)
     {
         var conventions = finder.Find<IColumnConvention>();
 
-        Apply<IColumnInspector, IColumnInstance>(conventions,
-            new ColumnInstance(currentType, columnMapping));
+        Apply(conventions, new ColumnInstance(currentType, columnMapping));
     }
 
     public override void ProcessCollection(CollectionMapping mapping)
     {
         var generalConventions = finder.Find<ICollectionConvention>();
 
-        Apply<ICollectionInspector, ICollectionInstance>(generalConventions,
-            new CollectionInstance(mapping));
+        Apply(generalConventions, new CollectionInstance(mapping));
 
         if (mapping.Relationship is ManyToManyMapping)
         {
             var conventions = finder.Find<IHasManyToManyConvention>();
 
-            Apply<IManyToManyCollectionInspector, IManyToManyCollectionInstance>(conventions,
-                new ManyToManyCollectionInstance(mapping));
+            Apply(conventions, new ManyToManyCollectionInstance(mapping));
         }
         else
         {
             var conventions = finder.Find<IHasManyConvention>();
 
-            Apply<IOneToManyCollectionInspector, IOneToManyCollectionInstance>(conventions,
-                new OneToManyCollectionInstance(mapping));
+            Apply(conventions, new OneToManyCollectionInstance(mapping));
         }
 
         collections[mapping.Collection](mapping);
@@ -112,65 +103,57 @@ void ProcessArray(CollectionMapping mapping)
     {
         var conventions = finder.Find<IArrayConvention>();
 
-        Apply<IArrayInspector, IArrayInstance>(conventions,
-            new CollectionInstance(mapping));
+        Apply(conventions, new CollectionInstance(mapping));
     }
 
     void ProcessBag(CollectionMapping mapping)
     {
         var conventions = finder.Find<IBagConvention>();
 
-        Apply<IBagInspector, IBagInstance>(conventions,
-            new CollectionInstance(mapping));
+        Apply(conventions, new CollectionInstance(mapping));
     }
 
     void ProcessList(CollectionMapping mapping)
     {
         var conventions = finder.Find<IListConvention>();
 
-        Apply<IListInspector, IListInstance>(conventions,
-            new CollectionInstance(mapping));
+        Apply(conventions, new CollectionInstance(mapping));
     }
 
     void ProcessMap(CollectionMapping mapping)
     {
         var conventions = finder.Find<IMapConvention>();
 
-        Apply<IMapInspector, IMapInstance>(conventions,
-            new CollectionInstance(mapping));
+        Apply(conventions, new CollectionInstance(mapping));
     }
 
     void ProcessSet(CollectionMapping mapping)
     {
         var conventions = finder.Find<ISetConvention>();
 
-        Apply<ISetInspector, ISetInstance>(conventions,
-            new CollectionInstance(mapping));
+        Apply(conventions, new CollectionInstance(mapping));
     }
 #pragma warning restore 612,618
 
     public override void ProcessManyToOne(ManyToOneMapping mapping)
     {
         var conventions = finder.Find<IReferenceConvention>();
 
-        Apply<IManyToOneInspector, IManyToOneInstance>(conventions,
-            new ManyToOneInstance(mapping));
+        Apply(conventions, new ManyToOneInstance(mapping));
     }
 
     public override void ProcessVersion(VersionMapping mapping)
     {
         var conventions = finder.Find<IVersionConvention>();
 
-        Apply<IVersionInspector, IVersionInstance>(conventions,
-            new VersionInstance(mapping));
+        Apply(conventions, new VersionInstance(mapping));
     }
 
     public override void ProcessOneToOne(OneToOneMapping mapping)
     {
         var conventions = finder.Find<IHasOneConvention>();
 
-        Apply<IOneToOneInspector, IOneToOneInstance>(conventions,
-            new OneToOneInstance(mapping));
+        Apply(conventions, new OneToOneInstance(mapping));
     }
 
     public override void ProcessSubclass(SubclassMapping subclassMapping)
@@ -179,15 +162,13 @@ public override void ProcessSubclass(SubclassMapping subclassMapping)
         {
             var conventions = finder.Find<ISubclassConvention>();
 
-            Apply<ISubclassInspector, ISubclassInstance>(conventions,
-                new SubclassInstance(subclassMapping));
+            Apply(conventions, new SubclassInstance(subclassMapping));
         }
         else
         {
             var conventions = finder.Find<IJoinedSubclassConvention>();
 
-            Apply<IJoinedSubclassInspector, IJoinedSubclassInstance>(conventions,
-                new JoinedSubclassInstance(subclassMapping));
+            Apply(conventions, new JoinedSubclassInstance(subclassMapping));
         }
     }
 
@@ -197,71 +178,63 @@ public override void ProcessComponent(ComponentMapping mapping)
         {
             var conventions = finder.Find<IComponentConvention>();
 
-            Apply<IComponentInspector, IComponentInstance>(conventions,
-                new ComponentInstance(mapping));
+            Apply(conventions, new ComponentInstance(mapping));
         }
         else
         {
             var conventions = finder.Find<IDynamicComponentConvention>();
 
-            Apply<IDynamicComponentInspector, IDynamicComponentInstance>(conventions,
-                new DynamicComponentInstance(mapping));
+            Apply(conventions, new DynamicComponentInstance(mapping));
         }
     }
 
     public override void ProcessIndex(IndexMapping indexMapping)
     {
         var conventions = finder.Find<IIndexConvention>();
 
-        Apply<IIndexInspector, IIndexInstance>(conventions,
-            new IndexInstance(indexMapping));
+        Apply(conventions, new IndexInstance(indexMapping));
     }
 
     public override void ProcessIndex(IndexManyToManyMapping indexMapping)
     {
         var conventions = finder.Find<IIndexManyToManyConvention>();
 
-        Apply<IIndexManyToManyInspector, IIndexManyToManyInstance>(conventions,
-            new IndexManyToManyInstance(indexMapping));
+        Apply(conventions, new IndexManyToManyInstance(indexMapping));
     }
 
     public override void ProcessJoin(JoinMapping joinMapping)
     {
         var conventions = finder.Find<IJoinConvention>();
 
-        Apply<IJoinInspector, IJoinInstance>(conventions,
-            new JoinInstance(joinMapping));
+        Apply(conventions, new JoinInstance(joinMapping));
     }
 
     public override void ProcessKeyProperty(KeyPropertyMapping mapping)
     {
         var conventions = finder.Find<IKeyPropertyConvention>();
 
-        Apply<IKeyPropertyInspector, IKeyPropertyInstance>(conventions, 
-            new KeyPropertyInstance(mapping));
+        Apply(conventions, new KeyPropertyInstance(mapping));
     }
 
     public override void ProcessKeyManyToOne(KeyManyToOneMapping mapping)
     {
         var conventions = finder.Find<IKeyManyToOneConvention>();
 
-        Apply<IKeyManyToOneInspector, IKeyManyToOneInstance>(conventions, 
-            new KeyManyToOneInstance(mapping));
+        Apply(conventions, new KeyManyToOneInstance(mapping));
     }
 
     public override void ProcessAny(AnyMapping mapping)
     {
         var conventions = finder.Find<IAnyConvention>();
 
-        Apply<IAnyInspector, IAnyInstance>(conventions,
-            new AnyInstance(mapping));
+        Apply(conventions, new AnyInstance(mapping));
     }
 
-    static void Apply<TInspector, TInstance>(IEnumerable conventions, TInstance instance)
+    static void Apply<TInspector, TInstance>(IEnumerable<IConvention<TInspector, TInstance>> conventions, TInstance instance)
         where TInspector : IInspector
-        where TInstance : TInspector
+        where TInstance : class, TInspector
     {
-        foreach (IConvention<TInspector, TInstance> convention in conventions)
+        foreach (var convention in conventions)
         {
             var criteria = new ConcreteAcceptanceCriteria<TInspector>();
             var acceptance = convention as IConventionAcceptance<TInspector>;

Original file line number	Diff line number	Diff line change
`@@ -15,13 +15,13 @@ namespace FluentNHibernate.Visitors;`
`15`	`15`
`16`	`16`	`public class ConventionVisitor : DefaultMappingModelVisitor`
`17`	`17`	`{`
`18`		`- readonly Dictionary<Collection, Action<MappingModel.Collections.CollectionMapping>> collections;`
	`18`	`+ readonly Dictionary<Collection, Action<CollectionMapping>> collections;`
`19`	`19`	`readonly IConventionFinder finder;`
`20`	`20`	`Type currentType;`
`21`	`21`
`22`	`22`	`public ConventionVisitor(IConventionFinder finder)`
`23`	`23`	`{`
`24`		`- collections = new Dictionary<Collection, Action<MappingModel.Collections.CollectionMapping>>`
	`24`	`+ collections = new Dictionary<Collection, Action<CollectionMapping>>`
`25`	`25`	`{`
`26`	`26`	`{ Collection.Array, ProcessArray },`
`27`	`27`	`{ Collection.Bag, ProcessBag },`
`@@ -36,24 +36,21 @@ public override void ProcessHibernateMapping(HibernateMapping hibernateMapping)`
`36`	`36`	`{`
`37`	`37`	`var conventions = finder.Find<IHibernateMappingConvention>();`
`38`	`38`
`39`		`- Apply<IHibernateMappingInspector, IHibernateMappingInstance>(conventions,`
`40`		`- new HibernateMappingInstance(hibernateMapping));`
	`39`	`+ Apply(conventions, new HibernateMappingInstance(hibernateMapping));`
`41`	`40`	`}`
`42`	`41`
`43`	`42`	`public override void ProcessId(IdMapping idMapping)`
`44`	`43`	`{`
`45`	`44`	`var conventions = finder.Find<IIdConvention>();`
`46`	`45`
`47`		`- Apply<IIdentityInspector, IIdentityInstance>(conventions,`
`48`		`- new IdentityInstance(idMapping));`
	`46`	`+ Apply(conventions, new IdentityInstance(idMapping));`
`49`	`47`	`}`
`50`	`48`
`51`	`49`	`public override void ProcessCompositeId(CompositeIdMapping idMapping)`
`52`	`50`	`{`
`53`	`51`	`var conventions = finder.Find<ICompositeIdentityConvention>();`
`54`	`52`
`55`		`- Apply<ICompositeIdentityInspector, ICompositeIdentityInstance>(conventions,`
`56`		`- new CompositeIdentityInstance(idMapping));`
	`53`	`+ Apply(conventions, new CompositeIdentityInstance(idMapping));`
`57`	`54`	`}`
`58`	`55`
`59`	`56`	`public override void ProcessClass(ClassMapping classMapping)`
`@@ -62,46 +59,40 @@ public override void ProcessClass(ClassMapping classMapping)`
`62`	`59`
`63`	`60`	`currentType = classMapping.Type;`
`64`	`61`
`65`		`- Apply<IClassInspector, IClassInstance>(conventions,`
`66`		`- new ClassInstance(classMapping));`
	`62`	`+ Apply(conventions, new ClassInstance(classMapping));`
`67`	`63`	`}`
`68`	`64`
`69`	`65`	`public override void ProcessProperty(PropertyMapping propertyMapping)`
`70`	`66`	`{`
`71`	`67`	`var conventions = finder.Find<IPropertyConvention>();`
`72`	`68`
`73`		`- Apply<IPropertyInspector, IPropertyInstance>(conventions,`
`74`		`- new PropertyInstance(propertyMapping));`
	`69`	`+ Apply(conventions, new PropertyInstance(propertyMapping));`
`75`	`70`	`}`
`76`	`71`
`77`	`72`	`public override void ProcessColumn(ColumnMapping columnMapping)`
`78`	`73`	`{`
`79`	`74`	`var conventions = finder.Find<IColumnConvention>();`
`80`	`75`
`81`		`- Apply<IColumnInspector, IColumnInstance>(conventions,`
`82`		`- new ColumnInstance(currentType, columnMapping));`
	`76`	`+ Apply(conventions, new ColumnInstance(currentType, columnMapping));`
`83`	`77`	`}`
`84`	`78`
`85`	`79`	`public override void ProcessCollection(CollectionMapping mapping)`
`86`	`80`	`{`
`87`	`81`	`var generalConventions = finder.Find<ICollectionConvention>();`
`88`	`82`
`89`		`- Apply<ICollectionInspector, ICollectionInstance>(generalConventions,`
`90`		`- new CollectionInstance(mapping));`
	`83`	`+ Apply(generalConventions, new CollectionInstance(mapping));`
`91`	`84`
`92`	`85`	`if (mapping.Relationship is ManyToManyMapping)`
`93`	`86`	`{`
`94`	`87`	`var conventions = finder.Find<IHasManyToManyConvention>();`
`95`	`88`
`96`		`- Apply<IManyToManyCollectionInspector, IManyToManyCollectionInstance>(conventions,`
`97`		`- new ManyToManyCollectionInstance(mapping));`
	`89`	`+ Apply(conventions, new ManyToManyCollectionInstance(mapping));`
`98`	`90`	`}`
`99`	`91`	`else`
`100`	`92`	`{`
`101`	`93`	`var conventions = finder.Find<IHasManyConvention>();`
`102`	`94`
`103`		`- Apply<IOneToManyCollectionInspector, IOneToManyCollectionInstance>(conventions,`
`104`		`- new OneToManyCollectionInstance(mapping));`
	`95`	`+ Apply(conventions, new OneToManyCollectionInstance(mapping));`
`105`	`96`	`}`
`106`	`97`
`107`	`98`	`collections[mapping.Collection](mapping);`
`@@ -112,65 +103,57 @@ void ProcessArray(CollectionMapping mapping)`
`112`	`103`	`{`
`113`	`104`	`var conventions = finder.Find<IArrayConvention>();`
`114`	`105`
`115`		`- Apply<IArrayInspector, IArrayInstance>(conventions,`
`116`		`- new CollectionInstance(mapping));`
	`106`	`+ Apply(conventions, new CollectionInstance(mapping));`
`117`	`107`	`}`
`118`	`108`
`119`	`109`	`void ProcessBag(CollectionMapping mapping)`
`120`	`110`	`{`
`121`	`111`	`var conventions = finder.Find<IBagConvention>();`
`122`	`112`
`123`		`- Apply<IBagInspector, IBagInstance>(conventions,`
`124`		`- new CollectionInstance(mapping));`
	`113`	`+ Apply(conventions, new CollectionInstance(mapping));`
`125`	`114`	`}`
`126`	`115`
`127`	`116`	`void ProcessList(CollectionMapping mapping)`
`128`	`117`	`{`
`129`	`118`	`var conventions = finder.Find<IListConvention>();`
`130`	`119`
`131`		`- Apply<IListInspector, IListInstance>(conventions,`
`132`		`- new CollectionInstance(mapping));`
	`120`	`+ Apply(conventions, new CollectionInstance(mapping));`
`133`	`121`	`}`
`134`	`122`
`135`	`123`	`void ProcessMap(CollectionMapping mapping)`
`136`	`124`	`{`
`137`	`125`	`var conventions = finder.Find<IMapConvention>();`
`138`	`126`
`139`		`- Apply<IMapInspector, IMapInstance>(conventions,`
`140`		`- new CollectionInstance(mapping));`
	`127`	`+ Apply(conventions, new CollectionInstance(mapping));`
`141`	`128`	`}`
`142`	`129`
`143`	`130`	`void ProcessSet(CollectionMapping mapping)`
`144`	`131`	`{`
`145`	`132`	`var conventions = finder.Find<ISetConvention>();`
`146`	`133`
`147`		`- Apply<ISetInspector, ISetInstance>(conventions,`
`148`		`- new CollectionInstance(mapping));`
	`134`	`+ Apply(conventions, new CollectionInstance(mapping));`
`149`	`135`	`}`
`150`	`136`	`#pragma warning restore 612,618`
`151`	`137`
`152`	`138`	`public override void ProcessManyToOne(ManyToOneMapping mapping)`
`153`	`139`	`{`
`154`	`140`	`var conventions = finder.Find<IReferenceConvention>();`
`155`	`141`
`156`		`- Apply<IManyToOneInspector, IManyToOneInstance>(conventions,`
`157`		`- new ManyToOneInstance(mapping));`
	`142`	`+ Apply(conventions, new ManyToOneInstance(mapping));`
`158`	`143`	`}`
`159`	`144`
`160`	`145`	`public override void ProcessVersion(VersionMapping mapping)`
`161`	`146`	`{`
`162`	`147`	`var conventions = finder.Find<IVersionConvention>();`
`163`	`148`
`164`		`- Apply<IVersionInspector, IVersionInstance>(conventions,`
`165`		`- new VersionInstance(mapping));`
	`149`	`+ Apply(conventions, new VersionInstance(mapping));`
`166`	`150`	`}`
`167`	`151`
`168`	`152`	`public override void ProcessOneToOne(OneToOneMapping mapping)`
`169`	`153`	`{`
`170`	`154`	`var conventions = finder.Find<IHasOneConvention>();`
`171`	`155`
`172`		`- Apply<IOneToOneInspector, IOneToOneInstance>(conventions,`
`173`		`- new OneToOneInstance(mapping));`
	`156`	`+ Apply(conventions, new OneToOneInstance(mapping));`
`174`	`157`	`}`
`175`	`158`
`176`	`159`	`public override void ProcessSubclass(SubclassMapping subclassMapping)`
`@@ -179,15 +162,13 @@ public override void ProcessSubclass(SubclassMapping subclassMapping)`
`179`	`162`	`{`
`180`	`163`	`var conventions = finder.Find<ISubclassConvention>();`
`181`	`164`
`182`		`- Apply<ISubclassInspector, ISubclassInstance>(conventions,`
`183`		`- new SubclassInstance(subclassMapping));`
	`165`	`+ Apply(conventions, new SubclassInstance(subclassMapping));`
`184`	`166`	`}`
`185`	`167`	`else`
`186`	`168`	`{`
`187`	`169`	`var conventions = finder.Find<IJoinedSubclassConvention>();`
`188`	`170`
`189`		`- Apply<IJoinedSubclassInspector, IJoinedSubclassInstance>(conventions,`
`190`		`- new JoinedSubclassInstance(subclassMapping));`
	`171`	`+ Apply(conventions, new JoinedSubclassInstance(subclassMapping));`
`191`	`172`	`}`
`192`	`173`	`}`
`193`	`174`
`@@ -197,71 +178,63 @@ public override void ProcessComponent(ComponentMapping mapping)`
`197`	`178`	`{`
`198`	`179`	`var conventions = finder.Find<IComponentConvention>();`
`199`	`180`
`200`		`- Apply<IComponentInspector, IComponentInstance>(conventions,`
`201`		`- new ComponentInstance(mapping));`
	`181`	`+ Apply(conventions, new ComponentInstance(mapping));`
`202`	`182`	`}`
`203`	`183`	`else`
`204`	`184`	`{`
`205`	`185`	`var conventions = finder.Find<IDynamicComponentConvention>();`
`206`	`186`
`207`		`- Apply<IDynamicComponentInspector, IDynamicComponentInstance>(conventions,`
`208`		`- new DynamicComponentInstance(mapping));`
	`187`	`+ Apply(conventions, new DynamicComponentInstance(mapping));`
`209`	`188`	`}`
`210`	`189`	`}`
`211`	`190`
`212`	`191`	`public override void ProcessIndex(IndexMapping indexMapping)`
`213`	`192`	`{`
`214`	`193`	`var conventions = finder.Find<IIndexConvention>();`
`215`	`194`
`216`		`- Apply<IIndexInspector, IIndexInstance>(conventions,`
`217`		`- new IndexInstance(indexMapping));`
	`195`	`+ Apply(conventions, new IndexInstance(indexMapping));`
`218`	`196`	`}`
`219`	`197`
`220`	`198`	`public override void ProcessIndex(IndexManyToManyMapping indexMapping)`
`221`	`199`	`{`
`222`	`200`	`var conventions = finder.Find<IIndexManyToManyConvention>();`
`223`	`201`
`224`		`- Apply<IIndexManyToManyInspector, IIndexManyToManyInstance>(conventions,`
`225`		`- new IndexManyToManyInstance(indexMapping));`
	`202`	`+ Apply(conventions, new IndexManyToManyInstance(indexMapping));`
`226`	`203`	`}`
`227`	`204`
`228`	`205`	`public override void ProcessJoin(JoinMapping joinMapping)`
`229`	`206`	`{`
`230`	`207`	`var conventions = finder.Find<IJoinConvention>();`
`231`	`208`
`232`		`- Apply<IJoinInspector, IJoinInstance>(conventions,`
`233`		`- new JoinInstance(joinMapping));`
	`209`	`+ Apply(conventions, new JoinInstance(joinMapping));`
`234`	`210`	`}`
`235`	`211`
`236`	`212`	`public override void ProcessKeyProperty(KeyPropertyMapping mapping)`
`237`	`213`	`{`
`238`	`214`	`var conventions = finder.Find<IKeyPropertyConvention>();`
`239`	`215`
`240`		`- Apply<IKeyPropertyInspector, IKeyPropertyInstance>(conventions,`
`241`		`- new KeyPropertyInstance(mapping));`
	`216`	`+ Apply(conventions, new KeyPropertyInstance(mapping));`
`242`	`217`	`}`
`243`	`218`
`244`	`219`	`public override void ProcessKeyManyToOne(KeyManyToOneMapping mapping)`
`245`	`220`	`{`
`246`	`221`	`var conventions = finder.Find<IKeyManyToOneConvention>();`
`247`	`222`
`248`		`- Apply<IKeyManyToOneInspector, IKeyManyToOneInstance>(conventions,`
`249`		`- new KeyManyToOneInstance(mapping));`
	`223`	`+ Apply(conventions, new KeyManyToOneInstance(mapping));`
`250`	`224`	`}`
`251`	`225`
`252`	`226`	`public override void ProcessAny(AnyMapping mapping)`
`253`	`227`	`{`
`254`	`228`	`var conventions = finder.Find<IAnyConvention>();`
`255`	`229`
`256`		`- Apply<IAnyInspector, IAnyInstance>(conventions,`
`257`		`- new AnyInstance(mapping));`
	`230`	`+ Apply(conventions, new AnyInstance(mapping));`
`258`	`231`	`}`
`259`	`232`
`260`		`- static void Apply<TInspector, TInstance>(IEnumerable conventions, TInstance instance)`
	`233`	`+ static void Apply<TInspector, TInstance>(IEnumerable<IConvention<TInspector, TInstance>> conventions, TInstance instance)`
`261`	`234`	`where TInspector : IInspector`
`262`		`- where TInstance : TInspector`
	`235`	`+ where TInstance : class, TInspector`
`263`	`236`	`{`
`264`		`- foreach (IConvention<TInspector, TInstance> convention in conventions)`
	`237`	`+ foreach (var convention in conventions)`
`265`	`238`	`{`
`266`	`239`	`var criteria = new ConcreteAcceptanceCriteria<TInspector>();`
`267`	`240`	`var acceptance = convention as IConventionAcceptance<TInspector>;`