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); }