public void NestedInterfaceInGenericClass() { // See SD2-1626 DefaultProjectContent pc = new DefaultProjectContent(); pc.ReferencedContents.Add(SharedProjectContentRegistryForTests.Instance.Mscorlib); DefaultCompilationUnit cu = new DefaultCompilationUnit(pc); DefaultClass container = new DefaultClass(cu, "TestClass"); container.TypeParameters.Add(new DefaultTypeParameter(container, "T", 0)); DefaultClass innerClass = new DefaultClass(cu, container); innerClass.FullyQualifiedName = "TestClass.INestedInterface"; innerClass.ClassType = ClassType.Interface; innerClass.TypeParameters.Add(new DefaultTypeParameter(innerClass, "T", 0)); innerClass.Properties.Add(new DefaultProperty(innerClass, "P") { ReturnType = new GenericReturnType(innerClass.TypeParameters[0]), CanGet = true }); container.InnerClasses.Add(innerClass); pc.AddClassToNamespaceList(container); DefaultClass targetClass = new DefaultClass(cu, "TargetClass"); List <AbstractNode> nodes = new List <AbstractNode>(); IReturnType interf = new SearchClassReturnType(pc, targetClass, 0, 0, "TestClass.INestedInterface", 1); interf = new ConstructedReturnType(interf, new IReturnType[] { SharedProjectContentRegistryForTests.Instance.Mscorlib.GetClass("System.String", 0).DefaultReturnType }); CSharpCodeGenerator codeGen = new CSharpCodeGenerator(); codeGen.ImplementInterface(nodes, interf, true, targetClass); Assert.AreEqual(1, nodes.Count); CSharpOutputVisitor output = new CSharpOutputVisitor(); output.Options.IndentationChar = ' '; output.Options.IndentSize = 2; nodes[0].AcceptVisitor(output, null); Assert.AreEqual("string TestClass<string>.INestedInterface.P {\n get\n {\n throw new NotImplementedException();\n }\n}", output.Text.Replace("\r", "").Trim()); }
public void NestedInterfaceInGenericClass() { // See SD2-1626 DefaultProjectContent pc = new DefaultProjectContent(); pc.ReferencedContents.Add(SharedProjectContentRegistryForTests.Instance.Mscorlib); DefaultCompilationUnit cu = new DefaultCompilationUnit(pc); DefaultClass container = new DefaultClass(cu, "TestClass"); container.TypeParameters.Add(new DefaultTypeParameter(container, "T", 0)); DefaultClass innerClass = new DefaultClass(cu, container); innerClass.FullyQualifiedName = "TestClass.INestedInterface"; innerClass.ClassType = ClassType.Interface; innerClass.TypeParameters.Add(new DefaultTypeParameter(innerClass, "T", 0)); innerClass.Properties.Add(new DefaultProperty(innerClass, "P") { ReturnType = new GenericReturnType(innerClass.TypeParameters[0]), CanGet = true }); container.InnerClasses.Add(innerClass); pc.AddClassToNamespaceList(container); DefaultClass targetClass = new DefaultClass(cu, "TargetClass"); List<AbstractNode> nodes = new List<AbstractNode>(); IReturnType interf = new SearchClassReturnType(pc, targetClass, 0, 0, "TestClass.INestedInterface", 1); interf = new ConstructedReturnType(interf, new IReturnType[] { SharedProjectContentRegistryForTests.Instance.Mscorlib.GetClass("System.String", 0).DefaultReturnType }); CSharpCodeGenerator codeGen = new CSharpCodeGenerator(); codeGen.ImplementInterface(nodes, interf, true, targetClass); Assert.AreEqual(1, nodes.Count); CSharpOutputVisitor output = new CSharpOutputVisitor(); output.Options.IndentationChar = ' '; output.Options.IndentSize = 2; nodes[0].AcceptVisitor(output, null); Assert.AreEqual("string TestClass<string>.INestedInterface.P {\n get {\n throw new NotImplementedException();\n }\n}", output.Text.Replace("\r", "").Trim()); }
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(AST.TypeReference reference, IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, IProjectContent projectContent) { System.Diagnostics.Debug.Assert(projectContent != null); if (reference == null) { return(GetDefaultReturnType(projectContent)); } if (reference is AST.ArrayTypeReference) { AST.ArrayTypeReference arr = (AST.ArrayTypeReference)reference; return(new ArrayReturnType(projectContent, CreateReturnType(arr.ElementType, callingClass, callingMember, caretLine, caretColumn, projectContent), (arr.Rank != null) ? (int)arr.Rank.Value : 1)); } else if (reference is AST.SimpleTypeReference) { string name = ((AST.SimpleTypeReference)reference).Name; IReturnType rt; int typeParameterCount = (reference is AST.GenericTypeReference) ? ((AST.GenericTypeReference)reference).GenericArguments.Count : 0; if (name == "duck") { rt = new BooResolver.DuckClass(new DefaultCompilationUnit(projectContent)).DefaultReturnType; } else if (BooAmbience.ReverseTypeConversionTable.ContainsKey(name)) { rt = new GetClassReturnType(projectContent, BooAmbience.ReverseTypeConversionTable[name], typeParameterCount); } else if (callingClass == null) { rt = new GetClassReturnType(projectContent, name, typeParameterCount); } else { rt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, name, typeParameterCount); } if (typeParameterCount > 0) { AST.TypeReferenceCollection arguments = ((AST.GenericTypeReference)reference).GenericArguments; // GenericTypeReference derives from SimpleTypeReference IReturnType[] typeArguments = new IReturnType[arguments.Count]; for (int i = 0; i < typeArguments.Length; i++) { typeArguments[i] = CreateReturnType(arguments[i], callingClass, callingMember, caretLine, caretColumn, projectContent); } rt = new ConstructedReturnType(rt, typeArguments); } return(rt); } else if (reference is AST.CallableTypeReference) { AST.CallableTypeReference ctr = (AST.CallableTypeReference)reference; AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(new DefaultCompilationUnit(projectContent)); if (ctr.ReturnType != null) { amrt.MethodReturnType = CreateReturnType(ctr.ReturnType, callingClass, callingMember, caretLine, caretColumn, projectContent); } amrt.MethodParameters = new List <IParameter>(); AddParameters(ctr.Parameters, amrt.MethodParameters, callingMember, callingClass ?? new DefaultClass(new DefaultCompilationUnit(projectContent), "__Dummy")); return(amrt); } else { throw new NotSupportedException("unknown reference type: " + reference.ToString()); } }
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); }