Revert "Implemented better way to handle extension method invocations."

This reverts commit d4afc75413.

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@@ -2570,7 +2570,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 					foreach (var m in meths) {
 						if (!lookup.IsAccessible(m, isProtectedAllowed))
 							continue;
-						result.AddMember(new InvocatedExtensionMethod (m));
+						result.AddMember(m);
 					}
 				}
 			}

ICSharpCode.NRefactory.CSharp/ICSharpCode.NRefactory.CSharp.csproj

@@ -512,7 +512,6 @@
     <Compile Include="Refactoring\CodeActions\CreateEnumValue.cs" />
     <Compile Include="Resolver\AliasTypeResolveResult.cs" />
     <Compile Include="Resolver\AliasNamespaceResolveResult.cs" />
-    <Compile Include="Resolver\InvocatedExtensionMethod.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\ICSharpCode.NRefactory\ICSharpCode.NRefactory.csproj">

ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/RedundantWhereWithPredicateIssue.cs

@@ -47,9 +47,9 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				var whereResolve = ctx.Resolve (whereInvoke) as InvocationResolveResult;
 				if (whereResolve == null || whereResolve.Member.Name != "Where" || !IsQueryExtensionClass(whereResolve.Member.DeclaringTypeDefinition))
 					return;
-				if (whereResolve.Member.Parameters.Count != 1)
+				if (whereResolve.Member.Parameters.Count != 2)
 					return;
-				var predResolve = whereResolve.Member.Parameters [0];
+				var predResolve = whereResolve.Member.Parameters [1];
 				if (predResolve.Type.TypeParameterCount != 2)
 					return;
 				

ICSharpCode.NRefactory.CSharp/Resolver/InvocatedExtensionMethod.cs

@@ -1,365 +0,0 @@
-//
-// InvocatedExtensionMethod.cs
-//
-// Author:
-//       Mike Krüger <mkrueger@xamarin.com>
-//
-// Copyright (c) 2013 Xamarin Inc. (http://xamarin.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-using System;
-using ICSharpCode.NRefactory.TypeSystem;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace ICSharpCode.NRefactory.CSharp
-{
-	/// <summary>
-	/// An invocated extension method hides the extension parameter in its parameter list.
-	/// It's used to hide the internals of extension method invocation in certain situation to simulate the 
-	/// syntactic way of writing extension methods on semantic level.
-	/// </summary>
-	public class InvocatedExtensionMethod : IMethod
-	{
-		readonly IMethod baseMethod;
-
-		public IMethod InvocatedMethod {
-			get {
-				return baseMethod;
-			}
-		}
-
-		public InvocatedExtensionMethod(IMethod baseMethod)
-		{
-			this.baseMethod = baseMethod;
-		}
-
-		#region IMember implementation
-
-		public IMemberReference ToMemberReference()
-		{
-			return baseMethod.ToMemberReference ();
-		}
-
-		public IMember MemberDefinition {
-			get {
-				return baseMethod.MemberDefinition;
-			}
-		}
-
-		public IUnresolvedMember UnresolvedMember {
-			get {
-				return baseMethod.UnresolvedMember;
-			}
-		}
-
-		public IType ReturnType {
-			get {
-				return baseMethod.ReturnType;
-			}
-		}
-
-		public System.Collections.Generic.IList<IMember> ImplementedInterfaceMembers {
-			get {
-				return baseMethod.ImplementedInterfaceMembers;
-			}
-		}
-
-		public bool IsExplicitInterfaceImplementation {
-			get {
-				return baseMethod.IsExplicitInterfaceImplementation;
-			}
-		}
-
-		public bool IsVirtual {
-			get {
-				return baseMethod.IsVirtual;
-			}
-		}
-
-		public bool IsOverride {
-			get {
-				return baseMethod.IsOverride;
-			}
-		}
-
-		public bool IsOverridable {
-			get {
-				return baseMethod.IsOverridable;
-			}
-		}
-
-		#endregion
-
-		#region IMethod implementation
-
-		public System.Collections.Generic.IList<IUnresolvedMethod> Parts {
-			get {
-				return baseMethod.Parts;
-			}
-		}
-
-		public System.Collections.Generic.IList<IAttribute> ReturnTypeAttributes {
-			get {
-				return baseMethod.ReturnTypeAttributes;
-			}
-		}
-
-		public System.Collections.Generic.IList<ITypeParameter> TypeParameters {
-			get {
-				return baseMethod.TypeParameters;
-			}
-		}
-
-		public bool IsExtensionMethod {
-			get {
-				return baseMethod.IsExtensionMethod;
-			}
-		}
-
-		public bool IsConstructor {
-			get {
-				return baseMethod.IsConstructor;
-			}
-		}
-
-		public bool IsDestructor {
-			get {
-				return baseMethod.IsDestructor;
-			}
-		}
-
-		public bool IsOperator {
-			get {
-				return baseMethod.IsOperator;
-			}
-		}
-
-		public bool IsPartial {
-			get {
-				return baseMethod.IsPartial;
-			}
-		}
-
-		public bool IsAsync {
-			get {
-				return baseMethod.IsAsync;
-			}
-		}
-
-		public bool HasBody {
-			get {
-				return baseMethod.HasBody;
-			}
-		}
-
-		public bool IsAccessor {
-			get {
-				return baseMethod.IsAccessor;
-			}
-		}
-
-		public IMember AccessorOwner {
-			get {
-				return baseMethod.AccessorOwner;
-			}
-		}
-
-		#endregion
-
-		#region IParameterizedMember implementation
-		List<IParameter> parameters;
-		public System.Collections.Generic.IList<IParameter> Parameters {
-			get {
-				if (parameters == null)
-					parameters = new List<IParameter> (baseMethod.Parameters.Skip (1));
-				return parameters;
-			}
-		}
-
-		#endregion
-
-		#region IEntity implementation
-
-		public EntityType EntityType {
-			get {
-				return baseMethod.EntityType;
-			}
-		}
-
-		public DomRegion Region {
-			get {
-				return baseMethod.Region;
-			}
-		}
-
-		public DomRegion BodyRegion {
-			get {
-				return baseMethod.BodyRegion;
-			}
-		}
-
-		public ITypeDefinition DeclaringTypeDefinition {
-			get {
-				return baseMethod.DeclaringTypeDefinition;
-			}
-		}
-
-		public IType DeclaringType {
-			get {
-				return baseMethod.DeclaringType;
-			}
-		}
-
-		public IAssembly ParentAssembly {
-			get {
-				return baseMethod.ParentAssembly;
-			}
-		}
-
-		public System.Collections.Generic.IList<IAttribute> Attributes {
-			get {
-				return baseMethod.Attributes;
-			}
-		}
-
-		public ICSharpCode.NRefactory.Documentation.DocumentationComment Documentation {
-			get {
-				return baseMethod.Documentation;
-			}
-		}
-
-		public bool IsStatic {
-			get {
-				return baseMethod.IsStatic;
-			}
-		}
-
-		public bool IsAbstract {
-			get {
-				return baseMethod.IsAbstract;
-			}
-		}
-
-		public bool IsSealed {
-			get {
-				return baseMethod.IsSealed;
-			}
-		}
-
-		public bool IsShadowing {
-			get {
-				return baseMethod.IsShadowing;
-			}
-		}
-
-		public bool IsSynthetic {
-			get {
-				return baseMethod.IsSynthetic;
-			}
-		}
-
-		#endregion
-
-		#region IHasAccessibility implementation
-
-		public Accessibility Accessibility {
-			get {
-				return baseMethod.Accessibility;
-			}
-		}
-
-		public bool IsPrivate {
-			get {
-				return baseMethod.IsPrivate;
-			}
-		}
-
-		public bool IsPublic {
-			get {
-				return baseMethod.IsPublic;
-			}
-		}
-
-		public bool IsProtected {
-			get {
-				return baseMethod.IsProtected;
-			}
-		}
-
-		public bool IsInternal {
-			get {
-				return baseMethod.IsInternal;
-			}
-		}
-
-		public bool IsProtectedOrInternal {
-			get {
-				return baseMethod.IsProtectedOrInternal;
-			}
-		}
-
-		public bool IsProtectedAndInternal {
-			get {
-				return baseMethod.IsProtectedAndInternal;
-			}
-		}
-
-		#endregion
-
-		#region INamedElement implementation
-
-		public string FullName {
-			get {
-				return baseMethod.FullName;
-			}
-		}
-
-		public string Name {
-			get {
-				return baseMethod.Name;
-			}
-		}
-
-		public string ReflectionName {
-			get {
-				return baseMethod.ReflectionName;
-			}
-		}
-
-		public string Namespace {
-			get {
-				return baseMethod.Namespace;
-			}
-		}
-
-		#endregion
-
-		#region ICompilationProvider implementation
-
-		public ICompilation Compilation {
-			get {
-				return baseMethod.Compilation;
-			}
-		}
-
-		#endregion
-	}
-}
-

ICSharpCode.NRefactory.CSharp/Resolver/OverloadResolution.cs

@@ -950,8 +950,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (member == null)
 				throw new InvalidOperationException();
 			
-			if (this.IsExtensionMethodInvocation && member is IMethod)
+			if (this.IsExtensionMethodInvocation && member is SpecializedMethod)
-				member =new InvocatedExtensionMethod ((IMethod)member);
+				((SpecializedMethod)member).IsExtendedExtensionMethod = true;
 			return new CSharpInvocationResolveResult(
 				this.IsExtensionMethodInvocation ? new TypeResolveResult(member.DeclaringType) : targetResolveResult,
 				member,

ICSharpCode.NRefactory.Tests/CSharp/Resolver/ExtensionMethodTests.cs

@@ -54,22 +54,19 @@ namespace XN {
 			InvocationResolveResult mrr;
 			
 			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$a.F(1)$"));
-			var member = ((InvocatedExtensionMethod)mrr.Member).InvocatedMethod;
+			Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
-			Assert.AreEqual("XN.XC.F", member.FullName);
+			Assert.AreEqual("System.Int32", mrr.Member.Parameters[1].Type.FullName);
-			Assert.AreEqual("System.Int32", member.Parameters [1].Type.FullName);
 			
 			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$a.F(\"text\")$"));
-			member = ((InvocatedExtensionMethod)mrr.Member).InvocatedMethod;
+			Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
-			Assert.AreEqual("XN.XC.F", member.FullName);
+			Assert.AreEqual("System.String", mrr.Member.Parameters[1].Type.FullName);
-			Assert.AreEqual("System.String", member.Parameters[1].Type.FullName);
 			
 			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$b.F(1)$"));
 			Assert.AreEqual("B.F", mrr.Member.FullName);
 			
 			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$b.F(\"text\")$"));
-			member = ((InvocatedExtensionMethod)mrr.Member).InvocatedMethod;
+			Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
-			Assert.AreEqual("XN.XC.F", member.FullName);
+			Assert.AreEqual("System.String", mrr.Member.Parameters[1].Type.FullName);
-			Assert.AreEqual("System.String", member.Parameters[1].Type.FullName);
 			
 			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$c.F(1)$"));
 			Assert.AreEqual("C.F", mrr.Member.FullName);
@@ -146,9 +143,8 @@ public static class XC {
 ";
 			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("A[]", rr.Type.ReflectionName);
-			var member = ((InvocatedExtensionMethod)rr.Member).InvocatedMethod;
+			Assert.AreEqual("System.Linq.Enumerable.ToArray", rr.Member.FullName);
-			Assert.AreEqual("System.Linq.Enumerable.ToArray", member.FullName);
+			Assert.AreEqual("A", ((SpecializedMethod)rr.Member).TypeArguments.Single().ReflectionName);
-			Assert.AreEqual("A", ((SpecializedMethod)member).TypeArguments.Single().ReflectionName);
 		}
 		
 		[Test]

ICSharpCode.NRefactory.Tests/CSharp/Resolver/LinqTests.cs

@@ -349,10 +349,9 @@ class TestClass
 }";
 			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
-			var member = ((InvocatedExtensionMethod)rr.Member).InvocatedMethod;
+			Assert.AreEqual("SelectMany", rr.Member.Name);
-			Assert.AreEqual("SelectMany", member.Name);
+			Assert.AreEqual(3, rr.Member.Parameters.Count);
-			Assert.AreEqual(3, member.Parameters.Count);
+			var typeArguments = ((SpecializedMethod)rr.Member).TypeArguments;
-			var typeArguments = ((SpecializedMethod)member).TypeArguments;
 			Assert.AreEqual(3, typeArguments.Count);
 			Assert.AreEqual("System.String", typeArguments[0].ReflectionName, "TSource");
 			Assert.AreEqual("System.Char", typeArguments[1].ReflectionName, "TCollection");
@@ -372,10 +371,9 @@ class TestClass
 }";
 			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
-			var member = ((InvocatedExtensionMethod)rr.Member).InvocatedMethod;
+			Assert.AreEqual("SelectMany", rr.Member.Name);
-			Assert.AreEqual("SelectMany", member.Name);
+			Assert.AreEqual(3, rr.Member.Parameters.Count);
-			Assert.AreEqual(3, member.Parameters.Count);
+			var typeArguments = ((SpecializedMethod)rr.Member).TypeArguments;
-			var typeArguments = ((SpecializedMethod)member).TypeArguments;
 			Assert.AreEqual(3, typeArguments.Count);
 			Assert.AreEqual("System.String", typeArguments[0].ReflectionName, "TSource");
 			Assert.AreEqual("System.Char", typeArguments[1].ReflectionName, "TCollection");

ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj

@@ -47,7 +47,7 @@
     <DebugSymbols>True</DebugSymbols>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>none</DebugType>
+    <DebugType>PdbOnly</DebugType>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'net_4_5_Debug' ">
     <Optimize>False</Optimize>
@@ -57,9 +57,8 @@
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'net_4_5_Debug|AnyCPU' ">
-    <DebugType>full</DebugType>
+    <DebugType>Full</DebugType>
-    <DebugSymbols>True</DebugSymbols>
+    <DebugSymbols>true</DebugSymbols>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'net_4_5_Release' ">
     <Optimize>True</Optimize>
@@ -68,8 +67,8 @@
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'net_4_5_Release|AnyCPU' ">
-    <DebugType>none</DebugType>
+    <DebugType>PdbOnly</DebugType>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <DebugSymbols>false</DebugSymbols>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />

ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMethod.cs

@@ -154,6 +154,14 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 
+		/// <summary>
+		/// Gets/Sets whether the method is an extension method that are being called using extension method syntax.
+		/// </summary>
+		public bool IsExtendedExtensionMethod {
+			get;
+			set;
+		}
+		
 		public override IMemberReference ToMemberReference()
 		{
 			// Pass the MethodTypeArguments to the SpecializingMemberReference only if