Browse Source

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

This reverts commit d4afc75413.
pull/32/merge
Mike Krüger 13 years ago
parent
commit
c26f61e813
  1. 2
      ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs
  2. 1
      ICSharpCode.NRefactory.CSharp/ICSharpCode.NRefactory.CSharp.csproj
  3. 4
      ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/RedundantWhereWithPredicateIssue.cs
  4. 365
      ICSharpCode.NRefactory.CSharp/Resolver/InvocatedExtensionMethod.cs
  5. 4
      ICSharpCode.NRefactory.CSharp/Resolver/OverloadResolution.cs
  6. 20
      ICSharpCode.NRefactory.Tests/CSharp/Resolver/ExtensionMethodTests.cs
  7. 14
      ICSharpCode.NRefactory.Tests/CSharp/Resolver/LinqTests.cs
  8. 11
      ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj
  9. 8
      ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMethod.cs

2
ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@ -2570,7 +2570,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion @@ -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);
}
}
}

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

@ -512,7 +512,6 @@ @@ -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">

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

@ -47,9 +47,9 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring @@ -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;

365
ICSharpCode.NRefactory.CSharp/Resolver/InvocatedExtensionMethod.cs

@ -1,365 +0,0 @@ @@ -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
}
}

4
ICSharpCode.NRefactory.CSharp/Resolver/OverloadResolution.cs

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

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

@ -54,22 +54,19 @@ namespace XN { @@ -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", member.FullName);
Assert.AreEqual("System.Int32", member.Parameters [1].Type.FullName);
Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
Assert.AreEqual("System.Int32", mrr.Member.Parameters[1].Type.FullName);
mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$a.F(\"text\")$"));
member = ((InvocatedExtensionMethod)mrr.Member).InvocatedMethod;
Assert.AreEqual("XN.XC.F", member.FullName);
Assert.AreEqual("System.String", member.Parameters[1].Type.FullName);
Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
Assert.AreEqual("System.String", mrr.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", member.FullName);
Assert.AreEqual("System.String", member.Parameters[1].Type.FullName);
Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
Assert.AreEqual("System.String", mrr.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 { @@ -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", member.FullName);
Assert.AreEqual("A", ((SpecializedMethod)member).TypeArguments.Single().ReflectionName);
Assert.AreEqual("System.Linq.Enumerable.ToArray", rr.Member.FullName);
Assert.AreEqual("A", ((SpecializedMethod)rr.Member).TypeArguments.Single().ReflectionName);
}
[Test]

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

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

11
ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj

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

8
ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMethod.cs

@ -154,6 +154,14 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation @@ -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

Loading…
Cancel
Save