Daniel Grunwald
15 years ago
6 changed files with 280 additions and 465 deletions
@ -1,423 +0,0 @@
@@ -1,423 +0,0 @@
|
||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
||||
|
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Diagnostics; |
||||
using System.Linq; |
||||
using System.Text; |
||||
|
||||
namespace ICSharpCode.NRefactory.TypeSystem |
||||
{ |
||||
/// <summary>
|
||||
/// Inference engine for common base type / common super type.
|
||||
/// This is not used in the C# resolver, as C# does not have this kind of powerful type inference.
|
||||
/// The logic used by C# is implemented in <see cref="CSharp.Resolver.TypeInference.GetBestCommonType"/>.
|
||||
///
|
||||
/// This inference engine is intended for use in Refactorings.
|
||||
/// </summary>
|
||||
public sealed class CommonTypeInference |
||||
{ |
||||
// Note: I'm pretty sure this is wrong in some rare cases, and incomplete in others;
|
||||
// but it should be good enough 99% of the time.
|
||||
|
||||
// We use the term CommonBaseTypes(T,S) to denote the set { X | T <: X and S <: X }.
|
||||
// (if we had union types, the union "T|S" would be the most specific possible type X).
|
||||
|
||||
// We use the term CommonSubTypes(T,S) to denote the set { X | X <: T and X <: S }.
|
||||
// (if we had intersection types, the intersection "T|S" would be the least specific possible type X).
|
||||
|
||||
// Some examples to show the possible common base types:
|
||||
// Union(List<string>, List<object>) = {
|
||||
// IEnumerable<Union(string, object)> = IEnumerable<object>,
|
||||
// IList,
|
||||
// ICollection,
|
||||
// IEnumerable,
|
||||
// object,
|
||||
// }
|
||||
// Removing entries that are uninteresting as they as less specific than other existing entries, the result
|
||||
// of Union(List<string>, List<object>) is { IEnumerable<object>, IList }.
|
||||
|
||||
// The number of options can be extremely high, especially when dealing with common subtypes.
|
||||
// Intersect(IDisposable, ICloneable) will return all classes that implement both interfaces.
|
||||
// In fact, for certain kinds of class declarations, there will be an infinite number of options.
|
||||
// For this reason, this algorithm supports aborting the operation, either after a specific number of options
|
||||
// has been found; or using a CancellationToken (e.g. when user clicks Cancel, or simply when too much time has expired).
|
||||
|
||||
readonly ITypeResolveContext context; |
||||
readonly IConversions conversions; |
||||
|
||||
/// <summary>
|
||||
/// Creates a new CommonTypeInference instance.
|
||||
/// </summary>
|
||||
/// <param name="context">The type resolve context to use.</param>
|
||||
/// <param name="conversions">The language-specified conversion rules to use.</param>
|
||||
public CommonTypeInference(ITypeResolveContext context, IConversions conversions) |
||||
{ |
||||
if (context == null) |
||||
throw new ArgumentNullException("context"); |
||||
if (conversions == null) |
||||
throw new ArgumentNullException("conversions"); |
||||
this.context = context; |
||||
this.conversions = conversions; |
||||
} |
||||
|
||||
public IEnumerable<IType> CommonBaseTypes(IList<IType> inputTypes, bool useOnlyReferenceConversion = false) |
||||
{ |
||||
if (inputTypes == null) |
||||
throw new ArgumentNullException("inputTypes"); |
||||
if (inputTypes.Count == 0) |
||||
return EmptyList<IType>.Instance; |
||||
|
||||
// First test whether there is a type in the input that all other input types are convertible to
|
||||
IType potentialCommonBaseType = inputTypes[0]; |
||||
for (int i = 1; i < inputTypes.Count; i++) { |
||||
if (useOnlyReferenceConversion) { |
||||
if (conversions.ImplicitReferenceConversion(inputTypes[i], potentialCommonBaseType)) { |
||||
// OK, continue
|
||||
} else if (conversions.ImplicitReferenceConversion(potentialCommonBaseType, inputTypes[i])) { |
||||
potentialCommonBaseType = inputTypes[i]; |
||||
} else { |
||||
potentialCommonBaseType = null; |
||||
break; |
||||
} |
||||
} else { |
||||
if (conversions.ImplicitConversion(inputTypes[i], potentialCommonBaseType)) { |
||||
// OK, continue
|
||||
} else if (conversions.ImplicitConversion(potentialCommonBaseType, inputTypes[i])) { |
||||
potentialCommonBaseType = inputTypes[i]; |
||||
} else { |
||||
potentialCommonBaseType = null; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
if (potentialCommonBaseType != null) |
||||
return new[] { potentialCommonBaseType }; |
||||
|
||||
// If we're supposed to only use reference conversions, but there is a non-reference type left in the input,
|
||||
// we can give up.
|
||||
if (useOnlyReferenceConversion && inputTypes.Any(t => t.IsReferenceType != true)) |
||||
return EmptyList<IType>.Instance; |
||||
|
||||
// Debug output: input values
|
||||
Debug.WriteLine("CommonBaseTypes input = {"); |
||||
Debug.Indent(); |
||||
foreach (IType type in inputTypes) |
||||
Debug.WriteLine(type); |
||||
Debug.Unindent(); |
||||
Debug.WriteLine("}"); |
||||
|
||||
Dictionary<ITypeDefinition, TP[]> dict = new Dictionary<ITypeDefinition, TP[]>(); |
||||
HashSet<IType> potentialTypes = new HashSet<IType>(); |
||||
// Retrieve the initial candidates from the first bound
|
||||
// generic types go to dict, non-generic types directly go to potentialTypes
|
||||
foreach (IType baseType in inputTypes[0].GetAllBaseTypes(context)) { |
||||
ParameterizedType pt = baseType as ParameterizedType; |
||||
if (pt != null) { |
||||
TP[] tp = new TP[pt.TypeParameterCount]; |
||||
for (int i = 0; i < tp.Length; i++) { |
||||
tp[i] = new TP(pt.GetDefinition().TypeParameters[i], false); |
||||
tp[i].Bounds.Add(pt.TypeArguments[i]); |
||||
} |
||||
dict[pt.GetDefinition()] = tp; |
||||
} else { |
||||
potentialTypes.Add(baseType); |
||||
} |
||||
} |
||||
// Now retrieve candidates for all other bounds, and intersect the different sets of candidates.
|
||||
for (int i = 1; i < inputTypes.Count; i++) { |
||||
IEnumerable<IType> baseTypesForThisBound = inputTypes[i].GetAllBaseTypes(context); |
||||
HashSet<ITypeDefinition> genericTypeDefsForThisLowerBound = new HashSet<ITypeDefinition>(); |
||||
foreach (IType baseType in baseTypesForThisBound) { |
||||
ParameterizedType pt = baseType as ParameterizedType; |
||||
if (pt != null) { |
||||
TP[] tp; |
||||
if (dict.TryGetValue(pt.GetDefinition(), out tp)) { |
||||
genericTypeDefsForThisLowerBound.Add(pt.GetDefinition()); |
||||
for (int j = 0; j < tp.Length; j++) { |
||||
tp[j].Bounds.Add(pt.TypeArguments[j]); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
potentialTypes.IntersectWith(baseTypesForThisBound); |
||||
foreach (ITypeDefinition def in dict.Keys.ToArray()) { |
||||
if (!genericTypeDefsForThisLowerBound.Contains(def)) |
||||
dict.Remove(def); |
||||
} |
||||
} |
||||
|
||||
// Now figure out the generic types, and add them to potential types if possible.
|
||||
foreach (var pair in dict) { |
||||
Debug.WriteLine("CommonBaseTypes: " + pair.Key); |
||||
Debug.Indent(); |
||||
IType[][] typeArguments = Fix(pair.Value); |
||||
if (typeArguments != null) { |
||||
foreach (IType[] ta in AllCombinations(typeArguments)) { |
||||
IType result = new ParameterizedType(pair.Key, ta); |
||||
Debug.WriteLine("Result: " + result); |
||||
potentialTypes.Add(result); |
||||
} |
||||
} |
||||
Debug.Unindent(); |
||||
} |
||||
|
||||
// Debug output: list candidates found so far:
|
||||
Debug.WriteLine("CommonBaseTypes candidates = {"); |
||||
Debug.Indent(); |
||||
foreach (IType type in potentialTypes) |
||||
Debug.WriteLine(type); |
||||
Debug.Unindent(); |
||||
Debug.WriteLine("}"); |
||||
|
||||
// Remove redundant types
|
||||
foreach (IType type in potentialTypes.ToArray()) { |
||||
bool isRedundant = false; |
||||
foreach (IType otherType in potentialTypes) { |
||||
if (type != otherType && conversions.ImplicitReferenceConversion(otherType, type)) { |
||||
isRedundant = true; |
||||
break; |
||||
} |
||||
} |
||||
if (isRedundant) |
||||
potentialTypes.Remove(type); |
||||
} |
||||
|
||||
return potentialTypes; |
||||
} |
||||
|
||||
IType[][] Fix(TP[] tps) |
||||
{ |
||||
IType[][] typeArguments = new IType[tps.Length][]; |
||||
bool error = false; |
||||
for (int i = 0; i < tps.Length; i++) { |
||||
var tp = tps[i]; |
||||
Debug.WriteLine("Fixing " + tp); |
||||
Debug.Indent(); |
||||
switch (tp.Variance) { |
||||
case VarianceModifier.Covariant: |
||||
typeArguments[i] = CommonBaseTypes(tp.Bounds.ToArray(), true).ToArray(); |
||||
break; |
||||
case VarianceModifier.Contravariant: |
||||
typeArguments[i] = CommonSubTypes(tp.Bounds.ToArray(), true).ToArray(); |
||||
break; |
||||
default: // Invariant
|
||||
if (tp.Bounds.Count == 1) |
||||
typeArguments[i] = new IType[] { tp.Bounds.Single() }; |
||||
break; |
||||
} |
||||
Debug.Unindent(); |
||||
if (typeArguments[i] == null || typeArguments[i].Length == 0) { |
||||
Debug.WriteLine(" -> error"); |
||||
error = true; |
||||
break; |
||||
} else { |
||||
Debug.WriteLine(" -> " + string.Join(",", typeArguments[i].AsEnumerable())); |
||||
} |
||||
} |
||||
return error ? null : typeArguments; |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Performs the combinatorial explosion.
|
||||
/// </summary>
|
||||
IEnumerable<IType[]> AllCombinations(IType[][] typeArguments) |
||||
{ |
||||
int[] index = new int[typeArguments.Length]; |
||||
index[typeArguments.Length - 1] = -1; |
||||
while (true) { |
||||
int i; |
||||
for (i = index.Length - 1; i >= 0; i--) { |
||||
if (++index[i] == typeArguments[i].Length) |
||||
index[i] = 0; |
||||
else |
||||
break; |
||||
} |
||||
if (i < 0) |
||||
break; |
||||
IType[] r = new IType[typeArguments.Length]; |
||||
for (i = 0; i < r.Length; i++) { |
||||
r[i] = typeArguments[i][index[i]]; |
||||
} |
||||
yield return r; |
||||
} |
||||
} |
||||
|
||||
public IEnumerable<IType> CommonSubTypes(IList<IType> inputTypes, bool useOnlyReferenceConversion = false) |
||||
{ |
||||
if (inputTypes == null) |
||||
throw new ArgumentNullException("inputTypes"); |
||||
if (inputTypes.Count == 0) |
||||
return EmptyList<IType>.Instance; |
||||
|
||||
// First test whether there is a type in the input that can be converted to all other input types
|
||||
IType potentialCommonSubType = inputTypes[0]; |
||||
for (int i = 1; i < inputTypes.Count; i++) { |
||||
if (useOnlyReferenceConversion) { |
||||
if (conversions.ImplicitReferenceConversion(potentialCommonSubType, inputTypes[i])) { |
||||
// OK, continue
|
||||
} else if (conversions.ImplicitReferenceConversion(inputTypes[i], potentialCommonSubType)) { |
||||
potentialCommonSubType = inputTypes[i]; |
||||
} else { |
||||
potentialCommonSubType = null; |
||||
break; |
||||
} |
||||
} else { |
||||
if (conversions.ImplicitConversion(potentialCommonSubType, inputTypes[i])) { |
||||
// OK, continue
|
||||
} else if (conversions.ImplicitConversion(inputTypes[i], potentialCommonSubType)) { |
||||
potentialCommonSubType = inputTypes[i]; |
||||
} else { |
||||
potentialCommonSubType = null; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
if (potentialCommonSubType != null) |
||||
return new[] { potentialCommonSubType }; |
||||
|
||||
ITypeDefinition[] inputTypeDefinitions = new ITypeDefinition[inputTypes.Count]; |
||||
for (int i = 0; i < inputTypeDefinitions.Length; i++) { |
||||
inputTypeDefinitions[i] = inputTypes[i].GetDefinition(); |
||||
if (inputTypeDefinitions[i] == null) { |
||||
// if there's any array or pointer type, we cannot find a common subtype
|
||||
return EmptyList<IType>.Instance; |
||||
} |
||||
} |
||||
|
||||
// Debug output: input values
|
||||
Debug.WriteLine("CommonSubTypes input = {"); |
||||
Debug.Indent(); |
||||
foreach (IType type in inputTypes) |
||||
Debug.WriteLine(type); |
||||
Debug.Unindent(); |
||||
Debug.WriteLine("}"); |
||||
|
||||
// Now we're left with the open-ended quest to find a type that derives from all input types.
|
||||
List<ITypeDefinition> candidateTypeDefs = new List<ITypeDefinition>(); |
||||
foreach (ITypeDefinition d in context.GetAllClasses()) { |
||||
bool ok = true; |
||||
// first check whether the type is derived from all input types
|
||||
foreach (ITypeDefinition inputTypeDef in inputTypeDefinitions) { |
||||
if (!d.IsDerivedFrom(inputTypeDef, context)) { |
||||
ok = false; |
||||
break; |
||||
} |
||||
} |
||||
if (!ok) |
||||
continue; |
||||
// then check that the type isn't redundant (derives from existing candidate)
|
||||
foreach (ITypeDefinition oldCandidate in candidateTypeDefs) { |
||||
if (d.IsDerivedFrom(oldCandidate, context)) { |
||||
ok = false; |
||||
break; |
||||
} |
||||
} |
||||
if (!ok) |
||||
continue; |
||||
// remove all existing candidates that are made redundant by the new type
|
||||
candidateTypeDefs.RemoveAll(oldCandidate => oldCandidate.IsDerivedFrom(d, context)); |
||||
candidateTypeDefs.Add(d); // add new candidate
|
||||
} |
||||
|
||||
HashSet<IType> potentialTypes = new HashSet<IType>(); |
||||
foreach (var candidate in candidateTypeDefs) { |
||||
if (candidate.TypeParameterCount == 0) { |
||||
potentialTypes.Add(candidate); |
||||
continue; |
||||
} |
||||
Debug.WriteLine(" Considering " + candidate); |
||||
TP[] tp = new TP[candidate.TypeParameterCount]; |
||||
for (int i = 0; i < tp.Length; i++) { |
||||
tp[i] = new TP(candidate.TypeParameters[i], true); |
||||
} |
||||
// self-parameterize the candidate
|
||||
IType parameterizedCandidate = new ParameterizedType(candidate, candidate.TypeParameters); |
||||
foreach (var candidateBase in parameterizedCandidate.GetAllBaseTypes(context).OfType<ParameterizedType>()) { |
||||
for (int i = 0; i < inputTypeDefinitions.Length; i++) { |
||||
if (candidateBase.GetDefinition() == inputTypeDefinitions[i]) { |
||||
ParameterizedType pt = inputTypes[i] as ParameterizedType; |
||||
if (pt != null && pt.TypeParameterCount == candidateBase.TypeParameterCount) { |
||||
// HACK: only handle the trivial case
|
||||
// what actually needs to be done here is very much like C# type inference,
|
||||
// so I should probably restructure the code to reuse C#'s MakeLowerBoundInference etc.
|
||||
for (int j = 0; j < Math.Min(pt.TypeParameterCount, candidate.TypeParameterCount); j++) { |
||||
if (candidateBase.TypeArguments[j] == candidate.TypeParameters[j]) { |
||||
tp[j].Bounds.Add(pt.TypeArguments[j]); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
Debug.Indent(); |
||||
var typeArguments = Fix(tp); |
||||
if (typeArguments != null) { |
||||
foreach (IType[] ta in AllCombinations(typeArguments)) { |
||||
IType result = new ParameterizedType(candidate, ta); |
||||
Debug.WriteLine("Result: " + result); |
||||
potentialTypes.Add(result); |
||||
} |
||||
} |
||||
Debug.Unindent(); |
||||
} |
||||
|
||||
return potentialTypes; |
||||
} |
||||
|
||||
sealed class TP |
||||
{ |
||||
public readonly VarianceModifier Variance; |
||||
|
||||
public TP(ITypeParameter tp, bool negative) |
||||
{ |
||||
this.Variance = tp.Variance; |
||||
if (negative) { |
||||
switch (tp.Variance) { |
||||
case VarianceModifier.Covariant: |
||||
this.Variance = VarianceModifier.Contravariant; |
||||
break; |
||||
case VarianceModifier.Contravariant: |
||||
this.Variance = VarianceModifier.Covariant; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
public readonly HashSet<IType> Bounds = new HashSet<IType>(); |
||||
|
||||
#if DEBUG
|
||||
public override string ToString() |
||||
{ |
||||
StringBuilder b = new StringBuilder(); |
||||
b.Append('('); |
||||
if (this.Variance == VarianceModifier.Covariant) { |
||||
bool first = true; |
||||
foreach (IType type in Bounds) { |
||||
if (first) first = false; else b.Append(" | "); |
||||
b.Append(type); |
||||
} |
||||
b.Append(" <: "); |
||||
} |
||||
b.Append("TP"); |
||||
if (this.Variance == VarianceModifier.Contravariant) { |
||||
b.Append(" <: "); |
||||
bool first = true; |
||||
foreach (IType type in Bounds) { |
||||
if (first) first = false; else b.Append(" & "); |
||||
b.Append(type); |
||||
} |
||||
} else if (this.Variance == VarianceModifier.Invariant) { |
||||
foreach (IType type in Bounds) { |
||||
b.Append(" = "); |
||||
b.Append(type); |
||||
} |
||||
} |
||||
b.Append(')'); |
||||
return b.ToString(); |
||||
} |
||||
#endif
|
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,129 @@
@@ -0,0 +1,129 @@
|
||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
||||
|
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Collections.ObjectModel; |
||||
using System.Diagnostics; |
||||
using System.Linq; |
||||
using System.Text; |
||||
using ICSharpCode.NRefactory.TypeSystem.Implementation; |
||||
|
||||
namespace ICSharpCode.NRefactory.TypeSystem |
||||
{ |
||||
/// <summary>
|
||||
/// Represents the intersection of several types.
|
||||
/// </summary>
|
||||
public class IntersectionType : AbstractType |
||||
{ |
||||
readonly ReadOnlyCollection<IType> types; |
||||
|
||||
public ReadOnlyCollection<IType> Types { |
||||
get { return types; } |
||||
} |
||||
|
||||
private IntersectionType(IType[] types) |
||||
{ |
||||
Debug.Assert(types.Length >= 2); |
||||
this.types = Array.AsReadOnly(types); |
||||
} |
||||
|
||||
public static IType Create(IEnumerable<IType> types) |
||||
{ |
||||
IType[] arr = types.Where(t => t != null).Distinct().ToArray(); |
||||
if (arr.Length == 0) |
||||
return SharedTypes.UnknownType; |
||||
else if (arr.Length == 1) |
||||
return arr[0]; |
||||
else |
||||
return new IntersectionType(arr); |
||||
} |
||||
|
||||
public override string Name { |
||||
get { |
||||
StringBuilder b = new StringBuilder(); |
||||
foreach (var t in types) { |
||||
if (b.Length > 0) |
||||
b.Append(" & "); |
||||
b.Append(t.Name); |
||||
} |
||||
return b.ToString(); |
||||
} |
||||
} |
||||
|
||||
public override string ReflectionName { |
||||
get { |
||||
StringBuilder b = new StringBuilder(); |
||||
foreach (var t in types) { |
||||
if (b.Length > 0) |
||||
b.Append(" & "); |
||||
b.Append(t.ReflectionName); |
||||
} |
||||
return b.ToString(); |
||||
} |
||||
} |
||||
|
||||
public override Nullable<bool> IsReferenceType { |
||||
get { return null; } |
||||
} |
||||
|
||||
public override int GetHashCode() |
||||
{ |
||||
int hashCode = 0; |
||||
unchecked { |
||||
foreach (var t in types) { |
||||
hashCode *= 7137517; |
||||
hashCode += t.GetHashCode(); |
||||
} |
||||
} |
||||
return hashCode; |
||||
} |
||||
|
||||
public override bool Equals(IType other) |
||||
{ |
||||
IntersectionType o = other as IntersectionType; |
||||
if (o != null && types.Count == o.types.Count) { |
||||
for (int i = 0; i < types.Count; i++) { |
||||
if (!types[i].Equals(o.types[i])) |
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
public override IEnumerable<IType> GetBaseTypes(ITypeResolveContext context) |
||||
{ |
||||
return types; |
||||
} |
||||
|
||||
public override IEnumerable<IEvent> GetEvents(ITypeResolveContext context, Predicate<IEvent> filter) |
||||
{ |
||||
filter = FilterNonStatic(filter); |
||||
return types.SelectMany(t => t.GetEvents(context, filter)); |
||||
} |
||||
|
||||
public override IEnumerable<IMethod> GetMethods(ITypeResolveContext context, Predicate<IMethod> filter) |
||||
{ |
||||
filter = FilterNonStatic(filter); |
||||
return types.SelectMany(t => t.GetMethods(context, filter)); |
||||
} |
||||
|
||||
public override IEnumerable<IProperty> GetProperties(ITypeResolveContext context, Predicate<IProperty> filter) |
||||
{ |
||||
filter = FilterNonStatic(filter); |
||||
return types.SelectMany(t => t.GetProperties(context, filter)); |
||||
} |
||||
|
||||
public override IEnumerable<IField> GetFields(ITypeResolveContext context, Predicate<IField> filter) |
||||
{ |
||||
filter = FilterNonStatic(filter); |
||||
return types.SelectMany(t => t.GetFields(context, filter)); |
||||
} |
||||
|
||||
static Predicate<T> FilterNonStatic<T>(Predicate<T> filter) where T : class, IMember |
||||
{ |
||||
return member => !member.IsStatic && (filter == null || filter(member)); |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue