public static bool IsListReturnType(this IReturnType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (type.GetUnderlyingClass() != null)
{
return(type.GetUnderlyingClass().IsListType());
}
return(false);
}
public override bool IsAvailable(IReturnType parameterType)
{
var parameterTypeClass = parameterType.GetUnderlyingClass();
return(parameterTypeClass == null ||
(parameterTypeClass.ClassType != ClassType.Enum && parameterTypeClass.ClassType != ClassType.Struct));
}
public EventHandlerCompletitionDataProvider(string expression, ResolveResult resolveResult)
{
this.expression = expression;
this.resolveResult = resolveResult;
this.resolvedReturnType = resolveResult.ResolvedType;
this.resolvedClass = resolvedReturnType.GetUnderlyingClass();
}
/// <summary>
/// Determines if the specified type is a ResourceManager type that can
/// be handled by this resolver.
/// </summary>
/// <param name="type">The type that will be checked if it is a ResourceManager.</param>
/// <param name="sourceFileName">The name of the source code file where the reference to this type occurs.</param>
static bool IsResourceManager(IReturnType type, string sourceFileName)
{
IProject p = ProjectFileDictionaryService.GetProjectForFile(sourceFileName);
IProjectContent pc;
if (p == null)
{
pc = ParserService.CurrentProjectContent;
}
else
{
pc = ResourceResolverService.GetProjectContent(p);
}
if (pc == null)
{
return(false);
}
IClass c = type.GetUnderlyingClass();
if (c == null)
{
return(false);
}
IClass resourceManager = pc.GetClass("System.Resources.ResourceManager", 0);
if (resourceManager == null)
{
return(false);
}
return(c.CompareTo(resourceManager) == 0 || c.IsTypeInInheritanceTree(resourceManager));
}
MemberResolveResult ResolveProperty(string xmlNamespace, string className, string propertyName, bool allowAttached)
{
IProjectContent pc = parseInfo.BestCompilationUnit.ProjectContent;
IReturnType resolvedType = XamlCompilationUnit.FindType(pc, xmlNamespace, className);
if (resolvedType != null && resolvedType.GetUnderlyingClass() != null)
{
IMember member = resolvedType.GetProperties().Find(delegate(IProperty p) { return(p.Name == propertyName); });
if (member == null)
{
member = resolvedType.GetEvents().Find(delegate(IEvent p) { return(p.Name == propertyName); });
}
if (member == null && allowAttached)
{
member = resolvedType.GetMethods().Find(
delegate(IMethod p) {
return(p.IsStatic && p.Parameters.Count == 1 && p.Name == "Get" + propertyName);
});
}
if (member != null)
{
return(new MemberResolveResult(callingClass, null, member));
}
}
return(null);
}
public static string FormatName(this IReturnType type)
{
if (type == null)
{
return(string.Empty);
}
if (type.Name == "Nullable")
{
return(string.Format("{0}?", type.CastToConstructedReturnType().TypeArguments[0].FormatName()));
}
var formattedName = type.GetFormattedNameOrNull();
if (formattedName != null)
{
return(formattedName);
}
var underlyingClass = type.GetUnderlyingClass();
if (underlyingClass != null)
{
return(underlyingClass.FormatName());
}
return(type.Name);
}
private void AppendReturnType(StringBuilder builder, IReturnType returnType, bool forceFullyQualifiedName)
{
var arrayReturnType = returnType;
returnType = GetElementType(returnType);
if (returnType == null)
{
return;
}
var fullName = returnType.FullyQualifiedName;
string shortName;
var isConstructedType = returnType.IsConstructedReturnType;
if (fullName != null && !isConstructedType && TypeConversionTable.TryGetValue(fullName, out shortName))
{
builder.Append(shortName);
}
else
{
IClass c = returnType.GetUnderlyingClass();
if (c != null)
{
IList <IReturnType> ta = isConstructedType
? returnType.CastToConstructedReturnType().TypeArguments
: null;
AppendClassNameWithTypeParameters(builder, c, forceFullyQualifiedName || UseFullyQualifiedTypeNames,
false, ta);
}
else
{
if (UseFullyQualifiedTypeNames || forceFullyQualifiedName)
{
builder.Append(fullName);
}
else
{
builder.Append(returnType.Name);
}
if (isConstructedType)
{
builder.Append('<');
IList <IReturnType> ta = returnType.CastToConstructedReturnType().TypeArguments;
for (int i = 0; i < ta.Count; ++i)
{
if (i > 0)
{
builder.Append(", ");
}
AppendReturnType(builder, ta[i], false);
}
builder.Append('>');
}
}
}
UnpackArrayType(builder, arrayReturnType);
}
IReturnType FixTypeReferenceCasing(TypeReference tr, Location loc)
{
if (resolver.CompilationUnit == null)
{
return(null);
}
if (tr.IsNull)
{
return(null);
}
IReturnType rt = resolver.SearchType(tr.Type, tr.GenericTypes.Count, loc).Result;
if (rt != null)
{
IClass c = rt.GetUnderlyingClass();
if (c != null)
{
if (string.Equals(tr.Type, c.Name, StringComparison.InvariantCultureIgnoreCase))
{
tr.Type = c.Name;
}
}
}
return(rt);
}
static bool IsInvocable(IMember member)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
if (member is IMethod || member is IEvent)
{
return(true);
}
IProperty p = member as IProperty;
if (p != null && p.Parameters.Count > 0)
{
return(true);
}
IReturnType returnType = member.ReturnType;
if (returnType == null)
{
return(false);
}
IClass c = returnType.GetUnderlyingClass();
return(c != null && c.ClassType == ClassType.Delegate);
}
public static List <IList <IMember> > LookupMember(
IReturnType type, string name, IClass callingClass,
LanguageProperties language, bool isInvocation, bool?isAccessThoughReferenceOfCurrentClass)
{
if (language == null)
{
throw new ArgumentNullException("language");
}
if (isAccessThoughReferenceOfCurrentClass == null)
{
isAccessThoughReferenceOfCurrentClass = false;
IClass underlyingClass = type.GetUnderlyingClass();
if (underlyingClass != null)
{
isAccessThoughReferenceOfCurrentClass = underlyingClass.IsTypeInInheritanceTree(callingClass);
}
}
IEnumerable <IMember> members;
if (language == LanguageProperties.VBNet && language.NameComparer.Equals(name, "New"))
{
members = GetAllMembers(type).OfType <IMethod>().Where(m => m.IsConstructor).Select(m => (IMember)m);
}
else
{
members = GetAllMembers(type).Where(m => language.NameComparer.Equals(m.Name, name));
}
return(LookupMember(members, callingClass, (bool)isAccessThoughReferenceOfCurrentClass, isInvocation));
}
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);
}
bool MatchesRequest(ref SearchTypeRequest request, ref SearchTypeResult result)
{
if (result.NamespaceResult != null)
{
return(request.TypeParameterCount == 0);
}
else
{
IReturnType rt = result.Result;
if (rt == null)
{
return(false);
}
if (rt.TypeArgumentCount != request.TypeParameterCount)
{
return(false);
}
IClass c = rt.GetUnderlyingClass();
if (c != null)
{
return(IsAccessibleClass(c));
}
else
{
return(true);
}
}
}
protected bool ProvideContextCompletion(ITextEditor editor, IReturnType expected, char charTyped)
{
if (expected == null) return false;
IClass c = expected.GetUnderlyingClass();
if (c == null) return false;
if (c.ClassType == ClassType.Enum) {
CtrlSpaceCompletionItemProvider cdp = new NRefactoryCtrlSpaceCompletionItemProvider(languageProperties);
var ctrlSpaceList = cdp.GenerateCompletionList(editor);
if (ctrlSpaceList == null) return false;
ContextCompletionItemList contextList = new ContextCompletionItemList();
contextList.Items.AddRange(ctrlSpaceList.Items);
contextList.activationKey = charTyped;
foreach (CodeCompletionItem item in contextList.Items.OfType<CodeCompletionItem>()) {
IClass itemClass = item.Entity as IClass;
if (itemClass != null && c.FullyQualifiedName == itemClass.FullyQualifiedName && c.TypeParameters.Count == itemClass.TypeParameters.Count) {
contextList.SuggestedItem = item;
break;
}
}
if (contextList.SuggestedItem != null) {
if (charTyped != ' ') contextList.InsertSpace = true;
editor.ShowCompletionWindow(contextList);
return true;
}
}
return false;
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
IMethodOrProperty m = GetMethod(invocationExpression);
if (m == null)
{
// This might also be a delegate invocation:
// get the delegate's Invoke method
IReturnType targetType = invocationExpression.TargetObject.AcceptVisitor(this, data) as IReturnType;
if (targetType != null)
{
IClass c = targetType.GetUnderlyingClass();
if (c != null && c.ClassType == ClassType.Delegate)
{
// find the delegate's return type
m = c.Methods.Find(delegate(IMethod innerMethod) { return(innerMethod.Name == "Invoke"); });
}
}
}
if (m != null)
{
return(m.ReturnType);
}
else
{
return(null);
}
}
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)));
}
public EventHandlerCompletitionDataProvider(string expression, ResolveResult resolveResult)
{
this.expression = expression;
this.resolveResult = resolveResult;
this.resolvedReturnType = resolveResult.ResolvedType;
this.resolvedClass = resolvedReturnType.GetUnderlyingClass();
}
public override object VisitCastExpression(CastExpression castExpression, object data)
{
base.VisitCastExpression(castExpression, data);
if (resolver.CompilationUnit == null)
return null;
if (castExpression.CastType != CastType.TryCast) {
IReturnType targetType = ResolveType(castExpression.CastTo);
if (targetType != null) {
IClass targetClass = targetType.GetUnderlyingClass();
if (targetClass != null && (targetClass.ClassType == ClassType.Struct || targetClass.ClassType == ClassType.Enum)) {
// cast to value type is a conversion
castExpression.CastType = CastType.Conversion;
}
if (targetClass != null && targetClass.FullyQualifiedName == "System.Char") {
// C# cast to char is done using ChrW function
ResolveResult sourceRR = resolver.ResolveInternal(castExpression.Expression, ExpressionContext.Default);
IReturnType sourceType = sourceRR != null ? sourceRR.ResolvedType : null;
if (IsInteger(sourceType)) {
ReplaceCurrentNode(new IdentifierExpression("ChrW").Call(castExpression.Expression));
}
}
}
}
return null;
}
void ResolveMethodInType(IReturnType containingType, string methodName, ExpressionCollection arguments)
{
List <IMethod> methods = new List <IMethod>();
bool isClassInInheritanceTree = false;
if (callingClass != null)
{
isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(containingType.GetUnderlyingClass());
}
foreach (IMethod m in containingType.GetMethods())
{
if (IsSameName(m.Name, methodName) &&
m.IsAccessible(callingClass, isClassInInheritanceTree)
)
{
methods.Add(m);
}
}
if (methods.Count == 0)
{
ArrayList list = new ArrayList();
ResolveResult.AddExtensions(callingClass.ProjectContent.Language, list, callingClass, containingType);
foreach (IMethodOrProperty mp in list)
{
if (IsSameName(mp.Name, methodName) && mp is IMethod)
{
IMethod m = (IMethod)mp.CreateSpecializedMember();
m.Parameters.RemoveAt(0);
methods.Add(m);
}
}
}
ResolveInvocation(methods, arguments);
}
public static bool Equals(IReturnType rt1, IReturnType rt2)
{
if (rt1 == rt2)
{
return(true);
}
if (rt1 == null || rt2 == null)
{
return(false);
}
IClass c1 = rt1.GetUnderlyingClass();
IClass c2 = rt2.GetUnderlyingClass();
if (c1 == null && c2 == null)
{
// guess if the classes are equal
return(rt1.FullyQualifiedName == rt2.FullyQualifiedName && rt1.TypeArgumentCount == rt2.TypeArgumentCount);
}
else
{
if (c1 == c2)
{
return(true);
}
if (c1 == null || c2 == null)
{
return(false);
}
return(c1.FullyQualifiedName == c2.FullyQualifiedName && c1.TypeParameters.Count == c2.TypeParameters.Count);
}
}
public IMember GetMember(IReturnType type, string memberName)
{
if (type == null)
{
return(null);
}
bool isClassInInheritanceTree = false;
if (callingClass != null)
{
isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(type.GetUnderlyingClass());
}
foreach (IProperty p in type.GetProperties())
{
if (IsSameName(p.Name, memberName))
{
return(p);
}
}
foreach (IField f in type.GetFields())
{
if (IsSameName(f.Name, memberName))
{
return(f);
}
}
foreach (IEvent e in type.GetEvents())
{
if (IsSameName(e.Name, memberName))
{
return(e);
}
}
return(null);
}
protected override void Initialize()
{
base.Initialize();
Nodes.Clear();
IProjectContent content = c.ProjectContent;
if (content != null)
{
int count = c.BaseTypes.Count;
for (int i = 0; i < count; i++)
{
IReturnType baseType = c.GetBaseType(i);
IClass baseClass = (baseType != null) ? baseType.GetUnderlyingClass() : null;
if (baseClass != null)
{
new ClassNode(project, baseClass).AddTo(this);
}
}
}
if (Nodes.Count == 0)
{
SetIcon(ClosedIcon);
OpenedIcon = ClosedIcon = null;
}
}
public EventHandlerCompletionItemProvider(string expression, ResolveResult resolveResult)
{
_expression = expression;
_resolveResult = resolveResult;
_resolvedReturnType = resolveResult.ResolvedType;
_resolvedClass = _resolvedReturnType.GetUnderlyingClass();
}
public virtual IClass GetUnderlyingClass()
{
IReturnType baseType = BaseType;
IClass tmp = (baseType != null && TryEnter()) ? baseType.GetUnderlyingClass() : null;
busy = false;
return(tmp);
}
public void DefaultReturnTypeGetUnderlyClass_NewInstance_ReturnsOriginalMockClass()
{
MockClass c = new MockClass();
IReturnType returnType = c.DefaultReturnType;
IClass underlyingClass = returnType.GetUnderlyingClass();
Assert.AreEqual(c, underlyingClass);
}
/// <summary>
/// Returns null if base type is not an interface.
/// </summary>
public static CodeInterface CreateFromBaseType(IProjectContent projectContent, IReturnType baseType)
{
IClass baseTypeClass = baseType.GetUnderlyingClass();
if (baseTypeClass.ClassType == ClassType.Interface) {
return new CodeInterface(projectContent, baseType, baseTypeClass);
}
return null;
}
public virtual IClass GetUnderlyingClass()
{
IReturnType baseType = BaseType;
using (var l = busyManager.Enter(this)) {
return((l.Success && baseType != null) ? baseType.GetUnderlyingClass() : null);
}
}
internal static IMethod GetDelegateOrExpressionTreeSignature(IReturnType rt, bool allowExpressionTree)
{
if (rt == null)
return null;
IClass c = rt.GetUnderlyingClass();
if (allowExpressionTree && c != null && c.FullyQualifiedName == "System.Linq.Expressions.Expression") {
ConstructedReturnType crt = rt.CastToConstructedReturnType();
if (crt != null && crt.TypeArguments.Count == 1) {
// get delegate type from expression type
rt = crt.TypeArguments[0];
c = rt != null ? rt.GetUnderlyingClass() : null;
}
}
if (c != null && c.ClassType == ClassType.Delegate) {
return rt.GetMethods().FirstOrDefault((IMethod m) => m.Name == "Invoke");
}
return null;
}
public TypeExpressionContext(IReturnType baseType, bool isObjectCreation, bool readOnly)
{
if (baseType != null)
{
baseClass = baseType.GetUnderlyingClass();
}
this.isObjectCreation = isObjectCreation;
this.readOnly = readOnly;
}
/// <summary>
/// Returns null if base type is not an interface.
/// </summary>
public static CodeInterface CreateFromBaseType(IProjectContent projectContent, IReturnType baseType)
{
IClass baseTypeClass = baseType.GetUnderlyingClass();
if (baseTypeClass.ClassType == ClassType.Interface)
{
return(new CodeInterface(projectContent, baseType, baseTypeClass));
}
return(null);
}
public void DerivedTestBaseClassHasTestCaseBaseClass()
{
IReturnType baseType = c.BaseTypes[0];
IClass baseClass = baseType.GetUnderlyingClass();
IReturnType baseBaseType = baseClass.BaseTypes[0];
string actualBaseTypeName = baseBaseType.FullyQualifiedName;
string expectedBaseTypeName = "unittest.TestCase";
Assert.AreEqual(expectedBaseTypeName, actualBaseTypeName);
}
public static bool IsUserCode(this IReturnType rt)
{
if (rt == null)
{
return(false);
}
IClass c = rt.GetUnderlyingClass();
return(c != null && IsUserCode(c));
}
MemberResolveResult ResolveProperty(string xmlNamespace, string className, string propertyName, bool allowAttached)
{
IProjectContent pc = context.ProjectContent;
IReturnType resolvedType = XamlCompilationUnit.FindType(pc, xmlNamespace, className);
if (resolvedType != null && resolvedType.GetUnderlyingClass() != null)
{
return(ResolvePropertyName(resolvedType, propertyName, allowAttached));
}
return(null);
}
public override object VisitCastExpression(CastExpression castExpression, object data)
{
base.VisitCastExpression(castExpression, data);
if (resolver.CompilationUnit == null)
{
return(null);
}
IReturnType targetType = ResolveType(castExpression.CastTo);
IClass targetClass = targetType != null?targetType.GetUnderlyingClass() : null;
if (castExpression.CastType != CastType.TryCast)
{
if (targetClass != null && (targetClass.ClassType == ClassType.Struct || targetClass.ClassType == ClassType.Enum))
{
// cast to value type is a conversion
castExpression.CastType = CastType.Conversion;
if (IsInteger(targetType))
{
ResolveResult sourceRR = resolver.ResolveInternal(castExpression.Expression, ExpressionContext.Default);
IReturnType sourceType = sourceRR != null ? sourceRR.ResolvedType : null;
if (IsFloatingPoint(sourceType))
{
// casts from float to int in C# truncate, but VB rounds
// we'll have to introduce a call to Math.Truncate
castExpression.Expression = ExpressionBuilder.Identifier("Math").Call("Truncate", castExpression.Expression);
}
else if (sourceType != null && sourceType.FullyQualifiedName == "System.Char")
{
// casts from char to int are valid in C#, but need to use AscW in VB
castExpression.Expression = ExpressionBuilder.Identifier("AscW").Call(castExpression.Expression);
if (targetType != null && targetType.FullyQualifiedName == "System.Int32")
{
// AscW already returns int, so skip the cast
ReplaceCurrentNode(castExpression.Expression);
return(null);
}
}
}
}
if (targetClass != null && targetClass.FullyQualifiedName == "System.Char")
{
// C# cast to char is done using ChrW function
ResolveResult sourceRR = resolver.ResolveInternal(castExpression.Expression, ExpressionContext.Default);
IReturnType sourceType = sourceRR != null ? sourceRR.ResolvedType : null;
if (IsInteger(sourceType))
{
ReplaceCurrentNode(new IdentifierExpression("ChrW").Call(castExpression.Expression));
}
}
}
return(null);
}
/// <summary>
/// Gets all accessible members, including indexers and constructors.
/// </summary>
public static List <IMember> GetAccessibleMembers(IReturnType rt, IClass callingClass, LanguageProperties language)
{
bool isAccessThoughReferenceOfCurrentClass = false;
IClass underlyingClass = rt.GetUnderlyingClass();
if (underlyingClass != null)
{
isAccessThoughReferenceOfCurrentClass = underlyingClass.IsTypeInInheritanceTree(callingClass);
}
return(GetAccessibleMembers(rt, callingClass, language, isAccessThoughReferenceOfCurrentClass));
}
static bool CanCompareEqualityWithOperator(IReturnType type)
{
// return true for value types except float and double
// return false for reference types except string.
IClass c = type.GetUnderlyingClass();
return c != null
&& c.FullyQualifiedName != "System.Single"
&& c.FullyQualifiedName != "System.Double"
&& (c.ClassType == Dom.ClassType.Struct
|| c.ClassType == Dom.ClassType.Enum
|| c.FullyQualifiedName == "System.String");
}
public static bool Equals(IReturnType rt1, IReturnType rt2)
{
if (rt1 == rt2) return true;
if (rt1 == null || rt2 == null) return false;
IClass c1 = rt1.GetUnderlyingClass();
IClass c2 = rt2.GetUnderlyingClass();
if (c1 == null && c2 == null) {
// guess if the classes are equal
return rt1.FullyQualifiedName == rt2.FullyQualifiedName && rt1.TypeArgumentCount == rt2.TypeArgumentCount;
} else {
if (c1 == c2)
return true;
if (c1 == null || c2 == null)
return false;
return c1.FullyQualifiedName == c2.FullyQualifiedName && c1.TypeParameters.Count == c2.TypeParameters.Count;
}
}
/// <summary>
/// Checks if an implicit conversion exists from <paramref name="from"/> to <paramref name="to"/>.
/// </summary>
public static bool ConversionExists(IReturnType from, IReturnType to)
{
// ECMA-334, § 13.1 Implicit conversions
// Identity conversion:
if (from == to) return true;
if (from == null || to == null) return false;
if (from.Equals(to)) {
return true;
}
bool fromIsDefault = from.IsDefaultReturnType;
bool toIsDefault = to.IsDefaultReturnType;
if (fromIsDefault && toIsDefault) {
// Implicit numeric conversions:
int f = GetPrimitiveType(from);
int t = GetPrimitiveType(to);
if (f == SByte && (t == Short || t == Int || t == Long || t == Float || t == Double || t == Decimal))
return true;
if (f == Byte && (t == Short || t == UShort || t == Int || t == UInt || t == Long || t == ULong || t == Float || t == Double || t == Decimal))
return true;
if (f == Short && (t == Int || t == Long || t == Float || t == Double || t == Decimal))
return true;
if (f == UShort && (t == Int || t == UInt || t == Long || t == ULong || t == Float || t == Double || t == Decimal))
return true;
if (f == Int && (t == Long || t == Float || t == Double || t == Decimal))
return true;
if (f == UInt && (t == Long || t == ULong || t == Float || t == Double || t == Decimal))
return true;
if ((f == Long || f == ULong) && (t == Float || t == Double || t == Decimal))
return true;
if (f == Char && (t == UShort || t == Int || t == UInt || t == Long || t == ULong || t == Float || t == Double || t == Decimal))
return true;
if (f == Float && t == Double)
return true;
}
// Implicit reference conversions:
if (toIsDefault && to.FullyQualifiedName == "System.Object") {
return true; // from any type to object
}
if (toIsDefault && (fromIsDefault || from.IsArrayReturnType)) {
IClass c1 = from.GetUnderlyingClass();
IClass c2 = to.GetUnderlyingClass();
if (c1 != null && c1.IsTypeInInheritanceTree(c2)) {
return true;
}
}
if (from.IsArrayReturnType && to.IsArrayReturnType) {
ArrayReturnType fromArt = from.CastToArrayReturnType();
ArrayReturnType toArt = to.CastToArrayReturnType();
// from array to other array type
if (fromArt.ArrayDimensions == toArt.ArrayDimensions) {
return ConversionExists(fromArt.ArrayElementType, toArt.ArrayElementType);
}
}
if (from.IsConstructedReturnType && to.IsConstructedReturnType) {
if (from.FullyQualifiedName == to.FullyQualifiedName) {
IList<IReturnType> fromTypeArguments = from.CastToConstructedReturnType().TypeArguments;
IList<IReturnType> toTypeArguments = to.CastToConstructedReturnType().TypeArguments;
if (fromTypeArguments.Count == toTypeArguments.Count) {
for (int i = 0; i < fromTypeArguments.Count; i++) {
if (fromTypeArguments[i] == toTypeArguments[i])
continue;
if (object.Equals(fromTypeArguments[i], toTypeArguments[i]))
continue;
if (!(toTypeArguments[i].IsGenericReturnType))
return false;
}
return true;
}
}
}
return false;
}
bool? IsReferenceType(IReturnType rt)
{
if (rt == null)
return null;
IClass c = rt.GetUnderlyingClass();
if (c == null)
return null;
switch (c.ClassType) {
case ClassType.Enum:
case ClassType.Struct:
return false;
default:
return true;
}
}
public TypeExpressionContext(IReturnType baseType, bool isObjectCreation, bool readOnly)
{
if (baseType != null)
baseClass = baseType.GetUnderlyingClass();
this.isObjectCreation = isObjectCreation;
this.readOnly = readOnly;
}
static bool AreTypesDifferent(IReturnType oldType, CodeTypeReference newType)
{
IClass oldClass = oldType.GetUnderlyingClass();
if (oldClass == null) {
// ignore type changes to untyped VB fields
return false;
}
if (newType.BaseType == "System.Void") {
// field types get replaced with System.Void if the type cannot be resolved
// (e.g. generic fields in the Boo designer which aren't converted to CodeDom)
// we'll ignore such type changes (fields should never have the type void)
return false;
}
ArrayReturnType oldArray = oldType.IsArrayReturnType ? oldType.CastToArrayReturnType() : null;
if (oldArray == null ^ newType.ArrayRank < 1)
{
return true;
}
if (oldArray == null) {
if (oldClass.DotNetName != newType.BaseType) {
return true;
}
} else {
if (oldArray.ArrayDimensions != newType.ArrayRank) {
return true;
}
if (AreTypesDifferent(oldArray.ArrayElementType, newType.ArrayElementType)) {
return true;
}
}
return false;
}
static string GetContentPropertyName(IReturnType type)
{
if (type == null)
return string.Empty;
IClass c = type.GetUnderlyingClass();
if (c == null)
return string.Empty;
IAttribute contentProperty = c.Attributes
.FirstOrDefault(attribute => attribute.AttributeType.FullyQualifiedName == "System.Windows.Markup.ContentPropertyAttribute");
if (contentProperty != null) {
return contentProperty.PositionalArguments.FirstOrDefault() as string
?? (contentProperty.NamedArguments.ContainsKey("Name") ? contentProperty.NamedArguments["Name"] as string : string.Empty);
}
return string.Empty;
}
public BaseType(TypeReference typeReference, IReturnType returnType)
{
this.TypeReference = typeReference;
this.ReturnType = returnType;
this.UnderlyingClass = returnType.GetUnderlyingClass();
}
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));
}
protected bool ProvideContextCompletion(SharpDevelopTextAreaControl editor, IReturnType expected, char charTyped)
{
if (expected == null) return false;
IClass c = expected.GetUnderlyingClass();
if (c == null) return false;
if (c.ClassType == ClassType.Enum) {
CtrlSpaceCompletionDataProvider cdp = new CtrlSpaceCompletionDataProvider();
ContextCompletionDataProvider cache = new ContextCompletionDataProvider(cdp);
cache.activationKey = charTyped;
cache.GenerateCompletionData(editor.FileName, editor.ActiveTextAreaControl.TextArea, charTyped);
ICompletionData[] completionData = cache.CompletionData;
Array.Sort(completionData, DefaultCompletionData.Compare);
for (int i = 0; i < completionData.Length; i++) {
CodeCompletionData ccd = completionData[i] as CodeCompletionData;
if (ccd != null && ccd.Class != null) {
if (ccd.Class.FullyQualifiedName == expected.FullyQualifiedName) {
cache.DefaultIndex = i;
break;
}
}
}
if (cache.DefaultIndex >= 0) {
if (charTyped != ' ') cdp.InsertSpace = true;
editor.ShowCompletionWindow(cache, charTyped);
return true;
}
}
return false;
}
bool IsEnum(IReturnType type)
{
var typeClass = type.GetUnderlyingClass();
if (typeClass == null)
// eg. MethodGroup type has no UnderlyingClass
return false;
return typeClass.ClassType == ICSharpCode.SharpDevelop.Dom.ClassType.Enum;
}
static bool IsValueType(IReturnType type)
{
IClass c = type.GetUnderlyingClass();
return c != null && (c.ClassType == Dom.ClassType.Struct || c.ClassType == Dom.ClassType.Enum);
}
void AppendReturnType(StringBuilder builder, IReturnType returnType, bool forceFullyQualifiedName)
{
IReturnType arrayReturnType = returnType;
returnType = GetElementType(returnType);
if (returnType == null)
return;
string fullName = returnType.FullyQualifiedName;
string shortName;
bool isConstructedType = returnType.IsConstructedReturnType;
if (fullName != null && !isConstructedType && TypeConversionTable.TryGetValue(fullName, out shortName)) {
builder.Append(shortName);
} else {
IClass c = returnType.GetUnderlyingClass();
if (c != null) {
IList<IReturnType> ta = isConstructedType ? returnType.CastToConstructedReturnType().TypeArguments : null;
AppendClassNameWithTypeParameters(builder, c, forceFullyQualifiedName || UseFullyQualifiedTypeNames, false, ta);
} else {
if (UseFullyQualifiedTypeNames || forceFullyQualifiedName) {
builder.Append(fullName);
} else {
builder.Append(returnType.Name);
}
if (isConstructedType) {
builder.Append('<');
IList<IReturnType> ta = returnType.CastToConstructedReturnType().TypeArguments;
for (int i = 0; i < ta.Count; ++i) {
if (i > 0) builder.Append(", ");
AppendReturnType(builder, ta[i], false);
}
builder.Append('>');
}
}
}
UnpackArrayType(builder, arrayReturnType);
}
void ResolveMethodInType(IReturnType containingType, string methodName, ExpressionCollection arguments)
{
List<IMethod> methods = new List<IMethod>();
bool isClassInInheritanceTree = false;
if (callingClass != null)
isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(containingType.GetUnderlyingClass());
foreach (IMethod m in containingType.GetMethods()) {
if (IsSameName(m.Name, methodName)
&& m.IsAccessible(callingClass, isClassInInheritanceTree)
) {
methods.Add(m);
}
}
if (methods.Count == 0) {
List<IMethodOrProperty> list = new List<IMethodOrProperty>();
ResolveResult.AddExtensions(callingClass.ProjectContent.Language, list.Add, callingClass, containingType);
foreach (IMethodOrProperty mp in list) {
if (IsSameName(mp.Name, methodName) && mp is IMethod) {
IMethod m = (IMethod)mp.CreateSpecializedMember();
m.Parameters.RemoveAt(0);
methods.Add(m);
}
}
}
ResolveInvocation(methods, arguments);
}
public TypeResolveResult(IClass callingClass, IMember callingMember, IReturnType resolvedType)
: base(callingClass, callingMember, resolvedType)
{
this.resolvedClass = resolvedType.GetUnderlyingClass();
}
public override bool IsAvailable(IReturnType parameterType)
{
var parameterTypeClass = parameterType.GetUnderlyingClass();
return (parameterTypeClass == null || parameterTypeClass.ClassType != ClassType.Enum && parameterTypeClass.ClassType != ClassType.Struct);
}
bool ResolveMember(IReturnType type, string memberName)
{
ClearResult();
if (type == null)
return false;
bool isClassInInheritanceTree = false;
if (callingClass != null)
isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(type.GetUnderlyingClass());
foreach (IProperty p in type.GetProperties()) {
if (IsSameName(p.Name, memberName)) {
MakeResult(p);
return true;
}
}
foreach (IField f in type.GetFields()) {
if (IsSameName(f.Name, memberName)) {
MakeResult(f);
return true;
}
}
foreach (IEvent e in type.GetEvents()) {
if (IsSameName(e.Name, memberName)) {
MakeResult(e);
return true;
}
}
foreach (IMethod m in type.GetMethods()) {
if (IsSameName(m.Name, memberName)) {
MakeMethodResult(type, memberName);
return true;
}
}
if (callingClass != null) {
List<IMethodOrProperty> list = new List<IMethodOrProperty>();
ResolveResult.AddExtensions(callingClass.ProjectContent.Language, list.Add, callingClass, type);
foreach (IMethodOrProperty mp in list) {
if (IsSameName(mp.Name, memberName)) {
if (mp is IMethod)
MakeMethodResult(type, memberName);
else
MakeResult(mp);
return true;
}
}
}
return false;
}
MemberResolveResult ResolvePropertyName(IReturnType resolvedType, string propertyName, bool allowAttached)
{
IMember member = resolvedType.GetProperties().Find(delegate(IProperty p) { return p.Name == propertyName; });
if (member == null) {
member = resolvedType.GetEvents().Find(delegate(IEvent p) { return p.Name == propertyName; });
}
if (member == null && allowAttached) {
IMethod method = resolvedType.GetMethods().Find(
delegate(IMethod p) {
return p.IsStatic && p.Parameters.Count == 1 && p.Name == "Get" + propertyName;
});
member = method;
if (member != null) {
member = new DefaultProperty(resolvedType.GetUnderlyingClass(), propertyName) { ReturnType = method.ReturnType };
} else {
IMethod m = resolvedType.GetMethods().Find(
delegate(IMethod p) {
return p.IsPublic && p.IsStatic && p.Parameters.Count == 2 && (p.Name == "Add" + propertyName + "Handler" || p.Name == "Remove" + propertyName + "Handler");
});
member = m;
if (member != null)
member = new DefaultEvent(resolvedType.GetUnderlyingClass(), propertyName) { ReturnType = m.Parameters[1].ReturnType };
}
}
if (member != null)
return new MemberResolveResult(callingClass, null, member);
return null;
}
public override bool IsAvailable(IReturnType parameterType)
{
IClass parameterTypeClass = parameterType.GetUnderlyingClass();
return (parameterTypeClass != null && parameterTypeClass.FullyQualifiedName == "System.Int32");
}
public static IEnumerable<ICompletionItem> MemberCompletion(XamlCompletionContext context, IReturnType type, string textPrefix)
{
if (type == null || type.GetUnderlyingClass() == null)
yield break;
var c = type.GetUnderlyingClass();
if (type is ConstructedReturnType && type.TypeArgumentCount > 0 && c.FullyQualifiedName == "System.Nullable") {
ConstructedReturnType rt = type as ConstructedReturnType;
string nullExtensionName = "Null";
if (!string.IsNullOrEmpty(context.XamlNamespacePrefix))
nullExtensionName = context.XamlNamespacePrefix + ":" + nullExtensionName;
yield return new SpecialCompletionItem("{" + nullExtensionName + "}");
c = rt.TypeArguments.First().GetUnderlyingClass();
if (c == null)
yield break;
}
bool isExplicit, showFull = false;
IReturnType typeName;
string valueBeforeCaret = (context.ValueStartOffset > 0) ?
context.RawAttributeValue.Substring(0, context.ValueStartOffset) : "";
switch (c.ClassType) {
case ClassType.Class:
switch (c.FullyQualifiedName) {
case "System.String":
// return nothing
break;
case "System.Type":
foreach (var item in CreateElementList(context, true, true))
yield return item;
break;
case "System.Windows.PropertyPath":
foreach (var item in CreatePropertyPathCompletion(context))
yield return item;
break;
case "System.Windows.DependencyProperty":
typeName = GetType(context, out isExplicit);
bool isReadOnly = context.ActiveElement.Name.EndsWith("Trigger");
if (!isExplicit && valueBeforeCaret.Contains("."))
showFull = true;
if (typeName != null) {
foreach (var item in typeName.GetDependencyProperties(true, !isExplicit, !isReadOnly, showFull))
yield return item;
}
break;
case "System.Windows.RoutedEvent":
typeName = GetType(context, out isExplicit);
if (!isExplicit && valueBeforeCaret.Contains("."))
showFull = true;
if (typeName != null) {
foreach (var item in typeName.GetRoutedEvents(true, !isExplicit, showFull))
yield return item;
}
break;
case "System.Windows.Media.FontFamily":
foreach (var font in Fonts.SystemFontFamilies)
yield return new SpecialValueCompletionItem(font.FamilyNames.First().Value);
break;
default:
if (context.Description == XamlContextDescription.InMarkupExtension) {
foreach (IField f in c.Fields)
yield return new XamlCodeCompletionItem(textPrefix + f.Name, f);
foreach (IProperty p in c.Properties.Where(pr => pr.IsPublic && pr.IsStatic && pr.CanGet))
yield return new XamlCodeCompletionItem(textPrefix + p.Name, p);
}
break;
}
break;
case ClassType.Enum:
foreach (IField f in c.Fields)
yield return new XamlCodeCompletionItem(textPrefix + f.Name, f);
foreach (IProperty p in c.Properties.Where(pr => pr.IsPublic && pr.IsStatic && pr.CanGet))
yield return new XamlCodeCompletionItem(textPrefix + p.Name, p);
break;
case ClassType.Struct:
switch (c.FullyQualifiedName) {
case "System.Boolean":
yield return new SpecialValueCompletionItem("True");
yield return new SpecialValueCompletionItem("False");
break;
case "System.Windows.GridLength":
yield return new SpecialValueCompletionItem("Auto");
yield return new SpecialValueCompletionItem("*");
break;
}
break;
case ClassType.Delegate:
foreach (var item in CreateEventCompletion(context, c))
yield return item;
break;
}
var classes = c.ProjectContent.Classes.Where(
cla => (cla.FullyQualifiedName == c.FullyQualifiedName + "s" ||
cla.FullyQualifiedName == c.FullyQualifiedName + "es"));
foreach (var coll in classes) {
foreach (var item in coll.Properties)
yield return new SpecialValueCompletionItem(item.Name);
foreach (var item in coll.Fields.Where(f => f.IsPublic && f.IsStatic && f.ReturnType.FullyQualifiedName == c.FullyQualifiedName))
yield return new SpecialValueCompletionItem(item.Name);
}
}
/// <summary>
/// Gets enum values out of enum type.
/// </summary>
IEnumerable<IField> GetEnumCases(IReturnType enumType)
{
var typeClass = enumType.GetUnderlyingClass();
if (typeClass == null) {
// eg. MethodGroup type has no UnderlyingClass
return Enumerable.Empty<IField>();
}
return typeClass.Fields;
}
/// <summary>
/// Determines if the specified type is a ResourceManager type that can
/// be handled by this resolver.
/// </summary>
/// <param name="type">The type that will be checked if it is a ResourceManager.</param>
/// <param name="sourceFileName">The name of the source code file where the reference to this type occurs.</param>
static bool IsResourceManager(IReturnType type, string sourceFileName)
{
IProject p = ProjectFileDictionaryService.GetProjectForFile(sourceFileName);
IProjectContent pc;
if (p == null) {
pc = ParserService.CurrentProjectContent;
} else {
pc = ResourceResolverService.GetProjectContent(p);
}
if (pc == null) {
return false;
}
IClass c = type.GetUnderlyingClass();
if (c == null) {
return false;
}
IClass resourceManager = pc.GetClass("System.Resources.ResourceManager", 0);
if (resourceManager == null) {
return false;
}
return (c.CompareTo(resourceManager) == 0 || c.IsTypeInInheritanceTree(resourceManager));
}
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;
}
/// <summary>
/// Gets the common base type of a and b.
/// </summary>
public static IReturnType GetCommonType(IProjectContent projectContent, IReturnType a, IReturnType b)
{
if (projectContent == null)
throw new ArgumentNullException("projectContent");
if (a == null) return b;
if (b == null) return a;
if (ConversionExists(a, b))
return b;
if (ConversionExists(b, a))
return a;
IClass c = a.GetUnderlyingClass();
if (c != null) {
foreach (IClass baseClass in c.ClassInheritanceTree) {
IReturnType baseType = baseClass.DefaultReturnType;
if (baseClass.TypeParameters.Count > 0) {
IReturnType[] typeArguments = new IReturnType[baseClass.TypeParameters.Count];
for (int i = 0; i < typeArguments.Length; i++) {
typeArguments[i] = GetTypeParameterPassedToBaseClass(a, baseClass, i);
}
baseType = new ConstructedReturnType(baseType, typeArguments);
}
if (ConversionExists(b, baseType))
return baseType;
}
}
return projectContent.SystemTypes.Object;
}
public static CodeClass2 CreateFromBaseType(IProjectContent projectContent, IReturnType baseType)
{
IClass baseTypeClass = baseType.GetUnderlyingClass();
return new CodeClass2(projectContent, baseTypeClass);
}
