Index: src/Boo.Lang.Compiler/Steps/ProcessMethodBodies.cs
===================================================================
--- src/Boo.Lang.Compiler/Steps/ProcessMethodBodies.cs	(révision 2780)
+++ src/Boo.Lang.Compiler/Steps/ProcessMethodBodies.cs	(copie de travail)
@@ -2516,7 +2516,16 @@
 				}
 				else if (candidates.AllEntitiesAre(EntityType.Method))
 				{
-					return ResolveAmbiguousMethodReference(node, candidates, EmptyExpressionCollection);
+					IEntity found = null;
+					if (!AstUtil.IsTargetOfGenericMethodInvocation(node)) {
+						Visit(((MethodInvocationExpression)node.ParentNode).Arguments);
+						found = ResolveAmbiguousMethodReference(node, candidates, ((MethodInvocationExpression)node.ParentNode).Arguments);
+					} else {
+						Visit(((MethodInvocationExpression)node.ParentNode.ParentNode).Arguments);
+						found = ResolveAmbiguousMethodReference(node, candidates, ((MethodInvocationExpression)node.ParentNode.ParentNode).Arguments);
+					}
+					_context.TraceVerbose("{0}: resolving ambiguous method reference : {1}", node.LexicalInfo, found);
+					return found;
 				}
 				else if (candidates.AllEntitiesAre(EntityType.Type))
 				{
@@ -2524,7 +2533,7 @@
 				}
 			}
 
-            return ResolveAmbiguousReferenceByAccessibility(candidates);
+			return ResolveAmbiguousReferenceByAccessibility(candidates);
 		}
 
         private IEntity ResolveAmbiguousMethodReference(ReferenceExpression node, Ambiguous candidates, ExpressionCollection args)
@@ -2536,9 +2545,9 @@
 			{
 				return candidates.Entities[0];
 			}
-			return candidates;
+			return GetCorrectCallableReference(node, args, candidates.Entities) ?? candidates;
 		}
-		
+
 		private IEntity ResolveAmbiguousPropertyReference(ReferenceExpression node, Ambiguous candidates, ExpressionCollection args)
 		{
 			IEntity[] entities = candidates.Entities;
@@ -3820,7 +3829,7 @@
 		
 		protected virtual IEntity ResolveAmbiguousMethodInvocation(MethodInvocationExpression node, Ambiguous entity)
 		{
-			_context.TraceVerbose("{0}: resolving ambigous method invocation: {1}", node.LexicalInfo, entity);
+			_context.TraceVerbose("{0}: resolving ambiguous method invocation: {1}", node.LexicalInfo, entity);
 
 			IEntity resolved = ResolveCallableReference(node, entity);
 			if (null != resolved) return resolved;
@@ -5205,7 +5214,7 @@
                 EnsureRelatedNodeWasVisited(sourceNode, candidate);
             }
 
-			IEntity found = _callableResolution.ResolveCallableReference(args, candidates);
+			IEntity found = _callableResolution.ResolveCallableReference(sourceNode as ReferenceExpression, args, candidates);
 			if (null == found) EmitCallableResolutionError(sourceNode, candidates, args);
 			return found;
 		}
Index: src/Boo.Lang.Compiler/Ast/AstUtil.cs
===================================================================
--- src/Boo.Lang.Compiler/Ast/AstUtil.cs	(révision 2780)
+++ src/Boo.Lang.Compiler/Ast/AstUtil.cs	(copie de travail)
@@ -202,10 +202,18 @@
 		
 		public static bool IsTargetOfMethodInvocation(Expression node)
 		{
-			return node.ParentNode.NodeType == NodeType.MethodInvocationExpression &&
-					node == ((MethodInvocationExpression)node.ParentNode).Target;
+			return IsTargetOfGenericMethodInvocation(node) ||
+				(node.ParentNode.NodeType == NodeType.MethodInvocationExpression &&
+					node == ((MethodInvocationExpression)node.ParentNode).Target);
 		}
 
+		public static bool IsTargetOfGenericMethodInvocation(Expression node)
+		{
+            return node.ParentNode.NodeType == NodeType.GenericReferenceExpression && node.ParentNode.ParentNode != null
+                    && node.ParentNode.ParentNode.NodeType == NodeType.MethodInvocationExpression
+                    && node.ParentNode == ((MethodInvocationExpression)node.ParentNode.ParentNode).Target;
+		}
+
 		public static bool IsTargetOfMemberReference(Expression node)
 		{
 			return node.ParentNode.NodeType == NodeType.MemberReferenceExpression &&
Index: src/Boo.Lang.Compiler/TypeSystem/CallableResolutionService.cs
===================================================================
--- src/Boo.Lang.Compiler/TypeSystem/CallableResolutionService.cs	(révision 2780)
+++ src/Boo.Lang.Compiler/TypeSystem/CallableResolutionService.cs	(copie de travail)
@@ -45,6 +45,7 @@
 		private const int ImplicitConversionScore = 5;
 		private const int NarrowingPromotion = 4;
 		private const int DowncastScore = 3;
+		private const int GenericScore = 1;
 
 		private List _candidates = new List();
 		private ExpressionCollection _arguments;
@@ -196,12 +197,27 @@
 		
 		public IEntity ResolveCallableReference(ExpressionCollection args, IEntity[] candidates)
 		{
+			return	ResolveCallableReference(null, args, candidates);
+		}
+		
+		//we need the sourceNode to deal with generic method invocations
+		public IEntity ResolveCallableReference(ReferenceExpression sourceNode, ExpressionCollection args, IEntity[] candidates)
+		{
 			Reset(args);
 			FindApplicableCandidates(candidates);
+
 			if (ValidCandidates.Count == 0) return null;
 			if (ValidCandidates.Count == 1) return ((Candidate)ValidCandidates[0]).Method;
 
-			List dataPreserving = ValidCandidates.Collect(DoesNotRequireConversions);
+			List dataPreserving = ValidCandidates;
+
+			//filter out non-generic candidates if necessary
+			if (null != sourceNode && AstUtil.IsTargetOfGenericMethodInvocation(sourceNode)) {
+				dataPreserving = dataPreserving.Collect(FilterNonGeneric);
+				if (dataPreserving.Count == 1) return ((Candidate)dataPreserving[0]).Method;
+			}
+			
+			dataPreserving = dataPreserving.Collect(DoesNotRequireConversions);
 			if (dataPreserving.Count > 0)
 			{
 				if (dataPreserving.Count == 1) return ((Candidate)dataPreserving[0]).Method;
@@ -211,6 +227,16 @@
 			return BestCandidate();
 		}
 
+		private static bool FilterNonGeneric(object candidate)
+		{
+			return Array.Exists(((Candidate) candidate).ArgumentScores, IsGenericScore);
+		}
+
+		private static bool IsGenericScore(int score)
+		{
+			return score == GenericScore;
+		}
+
 		private static bool DoesNotRequireConversions(object candidate)
 		{
 			return !Array.Exists(((Candidate) candidate).ArgumentScores, RequiresConversion);
@@ -482,6 +508,16 @@
 		private int CalculateArgumentScore(IParameter param, IType parameterType, Node arg)
 		{
 			IType argumentType = GetExpressionTypeOrEntityType(arg);
+
+			/*FIXME: HACK: if param is generic let's say it's ok and applicability will
+				be sorted out at construction step since currently we do not have 
+				constructed parameters here
+			 */
+			IGenericParameter genericParam = parameterType as IGenericParameter;
+			if (genericParam != null) {
+				return GenericScore;
+			}
+
 			if (param.IsByRef)
 			{
 				if (IsValidByRefArg(param, parameterType, argumentType, arg))