GenericReturnType CreateTWithDisposableConstraint() { GenericReturnType rt = CreateT(); rt.TypeParameter.Constraints.Add(msc.GetClass("System.IDisposable", 0).DefaultReturnType); return(rt); }
void CheckClass(IClass c) { Assert.AreSame(c, c.TypeParameters[0].Class); Assert.AreSame(c, c.TypeParameters[1].Class); Assert.AreSame(c.TypeParameters[1], ((GenericReturnType)c.TypeParameters[0].Constraints[0]).TypeParameter); IMethod m = c.Methods.Find(delegate(IMethod me) { return(me.Name == "TestMethod"); }); Assert.IsNotNull(m); Assert.AreEqual("K", m.TypeParameters[0].Name); Assert.AreEqual("V", m.TypeParameters[1].Name); Assert.AreSame(m, m.TypeParameters[0].Method); Assert.AreSame(m, m.TypeParameters[1].Method); Assert.AreEqual("IComparable", m.TypeParameters[0].Constraints[0].Name); GenericReturnType kConst = (GenericReturnType)m.TypeParameters[1].Constraints[0]; Assert.AreSame(m.TypeParameters[0], kConst.TypeParameter); m = c.Methods.Find(delegate(IMethod me) { return(me.Name == "GetIndex"); }); Assert.IsNotNull(m); Assert.AreEqual("T", m.TypeParameters[0].Name); Assert.AreSame(m, m.TypeParameters[0].Method); Assert.AreEqual("IEquatable", m.TypeParameters[0].Constraints[0].Name); Assert.AreEqual(1, m.TypeParameters[0].Constraints[0].TypeParameterCount); Assert.AreEqual(1, m.TypeParameters[0].Constraints[0].CastToConstructedReturnType().TypeArguments.Count); GenericReturnType grt = (GenericReturnType)m.TypeParameters[0].Constraints[0].CastToConstructedReturnType().TypeArguments[0]; Assert.AreSame(m.TypeParameters[0], grt.TypeParameter); }
public void GetIndex() { IMethod m = testClass.Methods.Single(me => me.Name == "GetIndex"); Assert.AreEqual("T", m.TypeParameters[0].Name); Assert.AreSame(m, m.TypeParameters[0].Method); Assert.AreEqual("IEquatable", m.TypeParameters[0].Constraints[0].Name); Assert.AreEqual(1, m.TypeParameters[0].Constraints[0].TypeArgumentCount); Assert.AreEqual(1, m.TypeParameters[0].Constraints[0].CastToConstructedReturnType().TypeArguments.Count); GenericReturnType grt = (GenericReturnType)m.TypeParameters[0].Constraints[0].CastToConstructedReturnType().TypeArguments[0]; Assert.AreSame(m.TypeParameters[0], grt.TypeParameter); }
public void TestMethod() { IMethod m = testClass.Methods.Single(me => me.Name == "TestMethod"); Assert.AreEqual("K", m.TypeParameters[0].Name); Assert.AreEqual("V", m.TypeParameters[1].Name); Assert.AreSame(m, m.TypeParameters[0].Method); Assert.AreSame(m, m.TypeParameters[1].Method); Assert.AreEqual("IComparable", m.TypeParameters[0].Constraints[0].Name); GenericReturnType kConst = (GenericReturnType)m.TypeParameters[1].Constraints[0]; Assert.AreSame(m.TypeParameters[0], kConst.TypeParameter); }
TP GetTPForType(IReturnType t) { if (t == null) { return(null); } GenericReturnType grt = t.CastToGenericReturnType(); if (grt != null) { return(typeParameters.FirstOrDefault(tp => tp.TypeParameter.Equals(grt.TypeParameter))); } return(null); }
/// <summary> /// Gets whether this type parameter occurs in the specified return type. /// </summary> public bool OccursIn(IReturnType rt) { ArrayReturnType art = rt.CastToArrayReturnType(); if (art != null) { return(OccursIn(art.ArrayElementType)); } ConstructedReturnType crt = rt.CastToConstructedReturnType(); if (crt != null) { return(crt.TypeArguments.Any(ta => OccursIn(ta))); } GenericReturnType grt = rt.CastToGenericReturnType(); if (grt != null) { return(this.TypeParameter.Equals(grt.TypeParameter)); } return(false); }
public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, IMember callingMember, int caretLine, int caretColumn, IProjectContent projectContent, bool useLazyReturnType) { if (reference == null) { return(null); } if (reference.IsNull) { return(null); } if (reference is InnerClassTypeReference) { reference = ((InnerClassTypeReference)reference).CombineToNormalTypeReference(); } LanguageProperties languageProperties = projectContent.Language; IReturnType t = null; if (callingClass != null && !reference.IsGlobal) { foreach (ITypeParameter tp in callingClass.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.SystemType)) { t = new GenericReturnType(tp); break; } } if (t == null && callingMember is IMethod && (callingMember as IMethod).TypeParameters != null) { foreach (ITypeParameter tp in (callingMember as IMethod).TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.SystemType)) { t = new GenericReturnType(tp); break; } } } } if (t == null) { if (reference.Type != reference.SystemType) { // keyword-type like void, int, string etc. IClass c = projectContent.GetClass(reference.SystemType); if (c != null) { t = c.DefaultReturnType; } else { t = new GetClassReturnType(projectContent, reference.SystemType, 0); } } else { int typeParameterCount = reference.GenericTypes.Count; if (useLazyReturnType) { if (reference.IsGlobal) { t = new GetClassReturnType(projectContent, reference.SystemType, typeParameterCount); } else if (callingClass != null) { t = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, reference.SystemType, typeParameterCount); } } else { IClass c; if (reference.IsGlobal) { c = projectContent.GetClass(reference.SystemType, typeParameterCount); t = (c != null) ? c.DefaultReturnType : null; } else if (callingClass != null) { t = projectContent.SearchType(new SearchTypeRequest(reference.SystemType, typeParameterCount, callingClass, caretLine, caretColumn)).Result; } if (t == null) { if (reference.GenericTypes.Count == 0 && !reference.IsArrayType) { // reference to namespace is possible if (reference.IsGlobal) { if (projectContent.NamespaceExists(reference.Type)) { return(new NamespaceReturnType(reference.Type)); } } else { string name = projectContent.SearchNamespace(reference.Type, callingClass, (callingClass == null) ? null : callingClass.CompilationUnit, caretLine, caretColumn); if (name != null) { return(new NamespaceReturnType(name)); } } } return(null); } } } } if (reference.GenericTypes.Count > 0) { List <IReturnType> para = new List <IReturnType>(reference.GenericTypes.Count); for (int i = 0; i < reference.GenericTypes.Count; ++i) { para.Add(CreateReturnType(reference.GenericTypes[i], callingClass, callingMember, caretLine, caretColumn, projectContent, useLazyReturnType)); } t = new ConstructedReturnType(t, para); } return(WrapArray(projectContent, t, reference)); }
public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, IMember callingMember, int caretLine, int caretColumn, IProjectContent projectContent, ReturnTypeOptions options) { if (reference == null) return null; if (reference.IsNull) return null; if (reference is InnerClassTypeReference) { reference = ((InnerClassTypeReference)reference).CombineToNormalTypeReference(); } bool useLazyReturnType = (options & ReturnTypeOptions.Lazy) == ReturnTypeOptions.Lazy; bool isBaseTypeReference = (options & ReturnTypeOptions.BaseTypeReference) == ReturnTypeOptions.BaseTypeReference; LanguageProperties languageProperties = projectContent.Language; IReturnType t = null; if (callingClass != null && !reference.IsGlobal) { foreach (ITypeParameter tp in callingClass.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.Type)) { t = new GenericReturnType(tp); break; } } IMethod callingMethod = callingMember as IMethod; if (t == null && callingMethod != null) { foreach (ITypeParameter tp in callingMethod.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.Type)) { t = new GenericReturnType(tp); break; } } } } if (t == null) { int typeParameterCount = reference.GenericTypes.Count; if (reference.IsKeyword) { // keyword-type like void, int, string etc. IClass c = projectContent.GetClass(reference.Type, typeParameterCount); if (c != null) t = c.DefaultReturnType; else t = new GetClassReturnType(projectContent, reference.Type, typeParameterCount); } else { if (useLazyReturnType || isBaseTypeReference) { if (reference.IsGlobal) { t = new GetClassReturnType(projectContent, reference.Type, typeParameterCount); } else if (callingClass != null) { SearchClassReturnType scrt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, reference.Type, typeParameterCount); if (isBaseTypeReference) scrt.LookForInnerClassesInDeclaringClass = false; t = scrt; } } else { IClass c; if (reference.IsGlobal) { c = projectContent.GetClass(reference.Type, typeParameterCount); t = (c != null) ? c.DefaultReturnType : null; } else if (callingClass != null) { t = projectContent.SearchType(new SearchTypeRequest(reference.Type, typeParameterCount, callingClass, caretLine, caretColumn)).Result; } if (t == null) { return null; } } } } if (reference.GenericTypes.Count > 0) { IReturnType[] para = new IReturnType[reference.GenericTypes.Count]; for (int i = 0; i < reference.GenericTypes.Count; ++i) { para[i] = CreateReturnType(reference.GenericTypes[i], callingClass, callingMember, caretLine, caretColumn, projectContent, options); } t = new ConstructedReturnType(t, para); } for (int i = 0; i < reference.PointerNestingLevel; i++) { t = new PointerReturnType(t); } return WrapArray(projectContent, t, reference); }
public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, IMember callingMember, int caretLine, int caretColumn, IProjectContent projectContent, ReturnTypeOptions options) { if (reference == null) { return(null); } if (reference.IsNull) { return(null); } if (reference is InnerClassTypeReference) { reference = ((InnerClassTypeReference)reference).CombineToNormalTypeReference(); } bool useLazyReturnType = (options & ReturnTypeOptions.Lazy) == ReturnTypeOptions.Lazy; bool isBaseTypeReference = (options & ReturnTypeOptions.BaseTypeReference) == ReturnTypeOptions.BaseTypeReference; LanguageProperties languageProperties = projectContent.Language; IReturnType t = null; if (callingClass != null && !reference.IsGlobal) { foreach (ITypeParameter tp in callingClass.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.Type)) { t = new GenericReturnType(tp); break; } } IMethod callingMethod = callingMember as IMethod; if (t == null && callingMethod != null) { foreach (ITypeParameter tp in callingMethod.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.Type)) { t = new GenericReturnType(tp); break; } } } } if (t == null && reference.Type == "dynamic") { t = new DynamicReturnType(projectContent); } if (t == null) { int typeParameterCount = reference.GenericTypes.Count; if (reference.IsKeyword) { // keyword-type like void, int, string etc. IClass c = projectContent.GetClass(reference.Type, typeParameterCount); if (c != null) { t = c.DefaultReturnType; } else { t = new GetClassReturnType(projectContent, reference.Type, typeParameterCount); } } else { if (useLazyReturnType || isBaseTypeReference) { if (reference.IsGlobal) { t = new GetClassReturnType(projectContent, reference.Type, typeParameterCount); } else if (callingClass != null) { SearchClassReturnType scrt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, reference.Type, typeParameterCount); if (isBaseTypeReference) { scrt.LookForInnerClassesInDeclaringClass = false; } t = scrt; } } else { IClass c; if (reference.IsGlobal) { c = projectContent.GetClass(reference.Type, typeParameterCount); t = (c != null) ? c.DefaultReturnType : null; } else if (callingClass != null) { t = projectContent.SearchType(new SearchTypeRequest(reference.Type, typeParameterCount, callingClass, caretLine, caretColumn)).Result; } if (t == null) { return(null); } } } } if (reference.GenericTypes.Count > 0) { IReturnType[] para = new IReturnType[reference.GenericTypes.Count]; for (int i = 0; i < reference.GenericTypes.Count; ++i) { para[i] = CreateReturnType(reference.GenericTypes[i], callingClass, callingMember, caretLine, caretColumn, projectContent, options); } t = new ConstructedReturnType(t, para); } for (int i = 0; i < reference.PointerNestingLevel; i++) { t = new PointerReturnType(t); } return(WrapArray(projectContent, t, reference)); }
public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, IMember callingMember, int caretLine, int caretColumn, IProjectContent projectContent, bool useLazyReturnType) { if (reference == null) return null; if (reference.IsNull) return null; if (reference is InnerClassTypeReference) { reference = ((InnerClassTypeReference)reference).CombineToNormalTypeReference(); } LanguageProperties languageProperties = projectContent.Language; IReturnType t = null; if (callingClass != null && !reference.IsGlobal) { foreach (ITypeParameter tp in callingClass.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.SystemType)) { t = new GenericReturnType(tp); break; } } if (t == null && callingMember is IMethod && (callingMember as IMethod).TypeParameters != null) { foreach (ITypeParameter tp in (callingMember as IMethod).TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.SystemType)) { t = new GenericReturnType(tp); break; } } } } if (t == null) { if (reference.Type != reference.SystemType) { // keyword-type like void, int, string etc. IClass c = projectContent.GetClass(reference.SystemType); if (c != null) t = c.DefaultReturnType; else t = new GetClassReturnType(projectContent, reference.SystemType, 0); } else { int typeParameterCount = reference.GenericTypes.Count; if (useLazyReturnType) { if (reference.IsGlobal) t = new GetClassReturnType(projectContent, reference.SystemType, typeParameterCount); else if (callingClass != null) t = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, reference.SystemType, typeParameterCount); } else { IClass c; if (reference.IsGlobal) { c = projectContent.GetClass(reference.SystemType, typeParameterCount); t = (c != null) ? c.DefaultReturnType : null; } else if (callingClass != null) { t = projectContent.SearchType(new SearchTypeRequest(reference.SystemType, typeParameterCount, callingClass, caretLine, caretColumn)).Result; } if (t == null) { if (reference.GenericTypes.Count == 0 && !reference.IsArrayType) { // reference to namespace is possible if (reference.IsGlobal) { if (projectContent.NamespaceExists(reference.Type)) return new NamespaceReturnType(reference.Type); } else { string name = projectContent.SearchNamespace(reference.Type, callingClass, (callingClass == null) ? null : callingClass.CompilationUnit, caretLine, caretColumn); if (name != null) return new NamespaceReturnType(name); } } return null; } } } } if (reference.GenericTypes.Count > 0) { List<IReturnType> para = new List<IReturnType>(reference.GenericTypes.Count); for (int i = 0; i < reference.GenericTypes.Count; ++i) { para.Add(CreateReturnType(reference.GenericTypes[i], callingClass, callingMember, caretLine, caretColumn, projectContent, useLazyReturnType)); } t = new ConstructedReturnType(t, para); } return WrapArray(projectContent, t, reference); }