public override void OnArrayLiteralExpression(ArrayLiteralExpression node)
{
if (node.Type != null)
{
MakeResult(ConvertType(node.Type));
return;
}
IReturnType elementType = null;
foreach (Expression expr in node.Items)
{
ClearResult();
expr.Accept(this);
IReturnType thisType = (resolveResult != null) ? resolveResult.ResolvedType : null;
if (elementType == null)
{
elementType = thisType;
}
else if (thisType != null)
{
elementType = MemberLookupHelper.GetCommonType(projectContent, elementType, thisType);
}
}
if (elementType == null)
{
elementType = ConvertVisitor.GetDefaultReturnType(projectContent);
}
MakeResult(new ArrayReturnType(projectContent, elementType, 1));
}
public override object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
{
switch (binaryOperatorExpression.Op)
{
case BinaryOperatorType.NullCoalescing:
return(binaryOperatorExpression.Right.AcceptVisitor(this, data));
case BinaryOperatorType.DivideInteger:
return(resolver.ProjectContent.SystemTypes.Int32);
case BinaryOperatorType.Concat:
return(resolver.ProjectContent.SystemTypes.String);
case BinaryOperatorType.Equality:
case BinaryOperatorType.InEquality:
case BinaryOperatorType.ReferenceEquality:
case BinaryOperatorType.ReferenceInequality:
case BinaryOperatorType.LogicalAnd:
case BinaryOperatorType.LogicalOr:
case BinaryOperatorType.LessThan:
case BinaryOperatorType.LessThanOrEqual:
case BinaryOperatorType.GreaterThan:
case BinaryOperatorType.GreaterThanOrEqual:
return(resolver.ProjectContent.SystemTypes.Boolean);
default:
return(MemberLookupHelper.GetCommonType(resolver.ProjectContent,
binaryOperatorExpression.Left.AcceptVisitor(this, data) as IReturnType,
binaryOperatorExpression.Right.AcceptVisitor(this, data) as IReturnType));
}
}
bool Fix(TP X)
{
Log("Trying to fix " + X);
Log(" bounds = ", X.Bounds);
List <IReturnType> candidates = new List <IReturnType>(X.Bounds);
foreach (IReturnType U in X.Bounds)
{
candidates.RemoveAll((IReturnType candidate) => !MemberLookupHelper.ConversionExists(U, candidate));
}
Log(" candidates after removal round = ", candidates);
if (candidates.Count == 0)
{
return(false);
}
var results = candidates.Where(
c1 => candidates.All(c2 => MemberLookupHelper.ConversionExists(c1, c2))
).ToList();
Log(" possible solutions (should be exactly one) = ", candidates);
if (results.Count == 1)
{
X.FixedTo = results[0];
return(true);
}
else
{
return(false);
}
}
public IProperty GetIndexer(IndexerExpression indexerExpression)
{
IReturnType type = (IReturnType)indexerExpression.TargetObject.AcceptVisitor(this, null);
if (type == null)
{
return(null);
}
List <IProperty> indexers = type.GetProperties();
// remove non-indexers:
for (int i = 0; i < indexers.Count; i++)
{
if (!indexers[i].IsIndexer)
{
indexers.RemoveAt(i--);
}
}
IReturnType[] parameters = new IReturnType[indexerExpression.Indexes.Count];
for (int i = 0; i < parameters.Length; i++)
{
Expression expr = indexerExpression.Indexes[i] as Expression;
if (expr != null)
{
parameters[i] = (IReturnType)expr.AcceptVisitor(this, null);
}
}
return(MemberLookupHelper.FindOverload(indexers.ToArray(), parameters));
}
public void LocalVariableAndFieldAreNotSimilarMembers()
{
IField field = new DefaultField(dummyClass.DefaultReturnType, "Test", ModifierEnum.None, DomRegion.Empty, dummyClass);
IField local = new DefaultField.LocalVariableField(dummyClass.DefaultReturnType, "Test", DomRegion.Empty, dummyClass);
Assert.IsFalse(MemberLookupHelper.IsSimilarMember(local, field));
}
public override object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data)
{
return(CreateResolveResult(MemberLookupHelper.GetCommonType(
resolver.ProjectContent,
ResolveType(conditionalExpression.TrueExpression),
ResolveType(conditionalExpression.FalseExpression))));
}
internal ResolveResult ResolveConstructorOverload(IReturnType rt, List <Expression> arguments)
{
if (rt == null)
{
return(null);
}
List <IMethod> methods = rt.GetMethods().Where(m => m.IsConstructor && !m.IsStatic).ToList();
IReturnType[] argumentTypes = arguments.Select <Expression, IReturnType>(ResolveType).ToArray();
bool resultIsAcceptable;
IMethod result = MemberLookupHelper.FindOverload(methods, argumentTypes, out resultIsAcceptable);
if (result == null)
{
IClass c = rt.GetUnderlyingClass();
if (c != null)
{
result = Constructor.CreateDefault(c);
}
}
ResolveResult rr = CreateMemberResolveResult(result);
if (rr != null)
{
rr.ResolvedType = rt;
}
return(rr);
}
static bool AllowsHelper(string baseClass, string methodName, IReturnType resolvedType, IProjectContent content)
{
IClass extensions = content.GetClass("System.Xml.Linq.Extensions", 0);
if (extensions == null)
{
return(false);
}
IMethod descendents = extensions.Methods.FirstOrDefault(m => m.Name == methodName);
if (descendents == null)
{
return(false);
}
IParameter param = descendents.Parameters.FirstOrDefault();
if (param == null)
{
return(false);
}
IClass resolvedTypeClass = resolvedType.GetUnderlyingClass();
if (resolvedTypeClass == null)
{
return(false);
}
return(MemberLookupHelper.IsApplicable(resolvedType, param, descendents) ||
resolvedTypeClass.IsTypeInInheritanceTree(content.GetClass(baseClass, 0)));
}
void FindOverrides(object sender, EventArgs e)
{
MenuCommand item = (MenuCommand)sender;
IMember member = (IMember)item.Tag;
IEnumerable <IClass> derivedClasses = RefactoringService.FindDerivedClasses(member.DeclaringType, ParserService.AllProjectContents, false);
List <SearchResultMatch> results = new List <SearchResultMatch>();
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedMemberNames | ConversionFlags.ShowTypeParameterList;
foreach (IClass derivedClass in derivedClasses)
{
if (derivedClass.CompilationUnit == null)
{
continue;
}
if (derivedClass.CompilationUnit.FileName == null)
{
continue;
}
IMember m = MemberLookupHelper.FindSimilarMember(derivedClass, member);
if (m != null && !m.Region.IsEmpty)
{
string matchText = ambience.Convert(m);
SearchResultMatch res = new SimpleSearchResultMatch(matchText, new TextLocation(m.Region.BeginColumn - 1, m.Region.BeginLine - 1));
res.ProvidedDocumentInformation = FindReferencesAndRenameHelper.GetDocumentInformation(m.DeclaringType.CompilationUnit.FileName);
results.Add(res);
}
}
SearchResultPanel.Instance.ShowSearchResults(new SearchResult(
StringParser.Parse("${res:SharpDevelop.Refactoring.OverridesOf}", new string[, ] {
{ "Name", member.Name }
}),
results
));
}
public void GetCommonTypeOfNullAndString()
{
IReturnType res = MemberLookupHelper.GetCommonType(msc,
NullReturnType.Instance,
msc.GetClass("System.String", 0).DefaultReturnType);
Assert.AreEqual("System.String", res.FullyQualifiedName);
}
public void GetCommonType()
{
IReturnType res = MemberLookupHelper.GetCommonType(msc,
swf.GetClass("System.Windows.Forms.ToolStripButton", 0).DefaultReturnType,
swf.GetClass("System.Windows.Forms.ToolStripSeparator", 0).DefaultReturnType);
Assert.AreEqual("System.Windows.Forms.ToolStripItem", res.FullyQualifiedName);
}
public void TypeParameterPassedToBaseClassSameClass()
{
IReturnType[] stringArr = { msc.SystemTypes.String };
IReturnType rrt = new ConstructedReturnType(EnumerableClass.DefaultReturnType, stringArr);
IReturnType res = MemberLookupHelper.GetTypeParameterPassedToBaseClass(rrt, EnumerableClass, 0);
Assert.AreEqual("System.String", res.FullyQualifiedName);
}
public void ArrayOfStringIsApplicableOnArrayOfT()
{
Assert.IsTrue(IsApplicable(new ArrayReturnType(msc, msc.SystemTypes.String, 1),
new ArrayReturnType(msc, CreateT(), 1)));
Assert.IsFalse(MemberLookupHelper.ConversionExists(new ArrayReturnType(msc, msc.SystemTypes.String, 1),
new ArrayReturnType(msc, CreateT(), 1)));
}
public void DisposableClassIsApplicableOnDisposableT()
{
Assert.IsFalse(MemberLookupHelper.ConversionExists(msc.GetClass("System.CharEnumerator", 0).DefaultReturnType,
CreateTWithDisposableConstraint()));
Assert.IsTrue(IsApplicable(msc.GetClass("System.CharEnumerator", 0).DefaultReturnType,
CreateTWithDisposableConstraint()));
}
public void TypeParameterPassedToBaseClassTestClassDerivingFromList()
{
DefaultClass listDerivingClass = CreateClassDerivingFromListOfString();
IReturnType res = MemberLookupHelper.GetTypeParameterPassedToBaseClass(listDerivingClass.DefaultReturnType,
EnumerableClass, 0);
Assert.AreEqual("System.String", res.FullyQualifiedName);
}
public void StringIsApplicableOnT()
{
// no conversion exists
Assert.IsFalse(MemberLookupHelper.ConversionExists(msc.SystemTypes.String,
CreateT()));
// but it is applicable
Assert.IsTrue(IsApplicable(msc.SystemTypes.String,
CreateT()));
}
public void NoConversionExistsFromStringToDisposableT()
{
// no conversion exists
Assert.IsFalse(MemberLookupHelper.ConversionExists(msc.SystemTypes.String,
CreateTWithDisposableConstraint()));
// but it is applicable (applicability ignores constraints)
Assert.IsTrue(IsApplicable(msc.SystemTypes.String,
CreateTWithDisposableConstraint()));
}
static IEnumerable <IMember> GetOverridableMembers(IClass c)
{
if (c == null)
{
throw new ArgumentException("c");
}
return(MemberLookupHelper.GetAccessibleMembers(c.BaseType, c, c.ProjectContent.Language, true)
.Where(m => m.IsOverridable && !m.IsConst));
}
public void NoConversionExistsFromParameterlessAnonymousDelegateToSystemPredicate()
{
AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(new DefaultCompilationUnit(msc));
amrt.MethodParameters = new List <IParameter>();
Assert.IsFalse(MemberLookupHelper.ConversionExists(
amrt,
new GetClassReturnType(msc, "System.Predicate", 1)
));
}
IProperty GetIndexer(IReturnType target, List <Expression> indexes)
{
if (target == null)
{
return(null);
}
return(MemberLookupHelper.FindOverload(
target.GetProperties().Where((IProperty p) => p.IsIndexer).ToList(),
indexes.Select <Expression, IReturnType>(ResolveType).ToArray()
));
}
void GoToBase(object sender, EventArgs e)
{
MenuCommand item = (MenuCommand)sender;
IMember member = (IMember)item.Tag;
IMember baseMember = MemberLookupHelper.FindBaseMember(member);
if (baseMember != null)
{
FindReferencesAndRenameHelper.JumpToDefinition(baseMember);
}
}
public static void ImplementAbstractClass(IRefactoringDocument doc, IClass target, IReturnType abstractClass)
{
CodeGenerator generator = target.ProjectContent.Language.CodeGenerator;
var pos = doc.OffsetToPosition(doc.PositionToOffset(target.BodyRegion.EndLine, target.BodyRegion.EndColumn) - 1);
ClassFinder context = new ClassFinder(target, pos.Line, pos.Column);
foreach (IMember member in MemberLookupHelper.GetAccessibleMembers(abstractClass, target, LanguageProperties.CSharp, true)
.Where(m => m.IsAbstract && !target.HasMember(m)))
{
generator.InsertCodeAtEnd(target.BodyRegion, doc, generator.GetOverridingMethod(member, context));
}
}
public void TypeParameterPassedToBaseClassTestGenericClassDerivingFromList()
{
DefaultClass listDerivingClass = CreateGenericClassDerivingFromList();
ConstructedReturnType testType = new ConstructedReturnType(listDerivingClass.DefaultReturnType,
new IReturnType[] { msc.SystemTypes.String });
IReturnType res = MemberLookupHelper.GetTypeParameterPassedToBaseClass(testType,
EnumerableClass, 0);
Assert.AreEqual("System.String", res.FullyQualifiedName);
}
public void TypeParameterPassedToBaseClassTestDictionary()
{
IReturnType[] stringInt = { msc.SystemTypes.String, msc.SystemTypes.Int32 };
IReturnType rrt = new ConstructedReturnType(DictionaryRT, stringInt);
IReturnType res = MemberLookupHelper.GetTypeParameterPassedToBaseClass(rrt, EnumerableClass, 0);
Assert.AreEqual("System.Collections.Generic.KeyValuePair", res.FullyQualifiedName);
ConstructedReturnType resc = res.CastToConstructedReturnType();
Assert.AreEqual("System.String", resc.TypeArguments[0].FullyQualifiedName);
Assert.AreEqual("System.Int32", resc.TypeArguments[1].FullyQualifiedName);
}
public void ConversionDoesNotExistFromAnonymousDelegateWithParameterToSystemPredicateWhenParameterTypeIsIncompatible()
{
AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(new DefaultCompilationUnit(msc));
amrt.MethodReturnType = msc.SystemTypes.Boolean;
amrt.MethodParameters = new List <IParameter>();
amrt.MethodParameters.Add(new DefaultParameter("test", msc.SystemTypes.String, DomRegion.Empty));
Assert.IsFalse(MemberLookupHelper.ConversionExists(
amrt,
new ConstructedReturnType(new GetClassReturnType(msc, "System.Predicate", 1),
new IReturnType[] { msc.SystemTypes.Int32 })
));
}
public override IReturnType ResolveReturnType(IReturnType[] parameterTypes)
{
if (lambdaExpression == null)
{
return(ResolveReturnType());
}
try {
MemberLookupHelper.Log("LambdaReturnType: SetImplicitLambdaParameterTypes ", parameterTypes);
resolver.SetImplicitLambdaParameterTypes(lambdaExpression, parameterTypes);
return(ResolveReturnType());
} finally {
resolver.UnsetImplicitLambdaParameterTypes(lambdaExpression);
}
}
protected ContextActionViewModel MakeGoToMemberAction(IClass containingClass, ObservableCollection <ContextActionViewModel> childActions)
{
var overridenMember = MemberLookupHelper.FindSimilarMember(containingClass, this.member);
if (overridenMember == null || overridenMember.Region.IsEmpty)
{
return(null);
}
return(new ContextActionViewModel {
Action = new GoToMemberAction(overridenMember, this.LabelAmbience),
Image = ClassBrowserIconService.GetIcon(overridenMember).ImageSource,
Comment = string.Format("(in {0})", containingClass.FullyQualifiedName),
ChildActions = childActions
});
}
public override void OnBinaryExpression(BinaryExpression node)
{
switch (node.Operator)
{
case BinaryOperatorType.GreaterThan:
case BinaryOperatorType.GreaterThanOrEqual:
case BinaryOperatorType.Equality:
case BinaryOperatorType.Inequality:
case BinaryOperatorType.LessThan:
case BinaryOperatorType.LessThanOrEqual:
case BinaryOperatorType.Match:
case BinaryOperatorType.Member:
case BinaryOperatorType.NotMatch:
case BinaryOperatorType.NotMember:
case BinaryOperatorType.ReferenceEquality:
case BinaryOperatorType.ReferenceInequality:
case BinaryOperatorType.TypeTest:
MakeResult(projectContent.SystemTypes.Boolean);
break;
default:
if (node.Left == null)
{
if (node.Right == null)
{
ClearResult();
}
else
{
node.Right.Accept(this);
}
return;
}
else if (node.Right == null)
{
node.Left.Accept(this);
return;
}
node.Left.Accept(this);
IReturnType left = (resolveResult != null) ? resolveResult.ResolvedType : null;
node.Right.Accept(this);
IReturnType right = (resolveResult != null) ? resolveResult.ResolvedType : null;
MakeResult(MemberLookupHelper.GetCommonType(projectContent, left, right));
break;
}
}
public IMethod FindOverload(List <IMethod> methods, IReturnType[] typeParameters, IList <Expression> arguments, object data)
{
if (methods.Count <= 0)
{
return(null);
}
// We can't use this shortcut because MemberLookupHelper does type inference and
// type substitution for us
//if (methods.Count == 1)
// return methods[0];
IReturnType[] types = new IReturnType[arguments.Count];
for (int i = 0; i < types.Length; ++i)
{
types[i] = arguments[i].AcceptVisitor(this, data) as IReturnType;
}
return(MemberLookupHelper.FindOverload(methods, typeParameters, types));
}
public void GetTypeInheritanceTreeOfStringArray()
{
List <string> results = new List <IReturnType>(
MemberLookupHelper.GetTypeInheritanceTree(new ArrayReturnType(msc, msc.SystemTypes.String, 1))
).ConvertAll <string>(delegate(IReturnType rt) { return(rt.DotNetName); });
results.Sort(); // order is not guaranteed, so sort for the unit test
Assert.AreEqual("System.Collections.Generic.ICollection{System.String};" +
"System.Collections.Generic.IEnumerable{System.String};" +
"System.Collections.Generic.IList{System.String};" +
"System.Collections.ICollection;" +
"System.Collections.IEnumerable;" +
"System.Collections.IList;" +
"System.Object;" +
"System.String[]",
string.Join(";", results.ToArray()));
}
