ResolveResult CreateResult(ICompilationUnit unit, IReturnType type) { MemberResolveResult result = new MemberResolveResult(null); result.CallingType = resolver.CallingType; result.CallingMember = resolver.CallingMember; result.ResolvedType = type; result.UnresolvedType = type; if (unit != null && resolver.Dom != null && type != null && type.Type == null) { IType searchedType = resolver.SearchType(type); if (searchedType != null) { DomReturnType resType = new DomReturnType(searchedType); resType.ArrayDimensions = type.ArrayDimensions; for (int i = 0; i < type.ArrayDimensions; i++) { resType.SetDimension(i, type.GetDimension(i)); } resType.PointerNestingLevel = type.PointerNestingLevel; result.ResolvedType = resType; } } return(result); }
public override INode Visit(IReturnType type, IMethod typeToInstantiate) { DomReturnType copyFrom = (DomReturnType)type; IReturnType res; if (typeTable.TryGetValue(copyFrom.DecoratedFullName, out res)) { if (type.ArrayDimensions > 0) { DomReturnType drr = new DomReturnType(res.FullName); drr.PointerNestingLevel = type.PointerNestingLevel; drr.ArrayDimensions = type.ArrayDimensions; if (!(type.Type is ITypeParameterType)) { drr.Type = type.Type; // May be anonymous type } for (int i = 0; i < type.ArrayDimensions; i++) { drr.SetDimension(i, type.GetDimension(i)); } return(drr); } return(res); } return(base.Visit(type, typeToInstantiate)); }
public void Add(IReturnType parameterType, IReturnType type) { //Console.WriteLine ("Add:" + parameterType +"->" + type); if (type == null || string.IsNullOrEmpty(type.FullName)) { return; } string name = parameterType.Name; if (!typeTable.ContainsKey(name)) { DomReturnType newType = new DomReturnType(type.FullName); newType.ArrayDimensions = Math.Max(0, type.ArrayDimensions - parameterType.ArrayDimensions); newType.PointerNestingLevel = Math.Max(0, type.PointerNestingLevel - parameterType.PointerNestingLevel); newType.Type = type.Type; // May be anonymous type for (int i = 0; i < newType.ArrayDimensions; i++) { newType.SetDimension(i, parameterType.GetDimension(i)); } foreach (var generic in type.GenericArguments) { newType.AddTypeParameter(generic); } typeTable[name] = newType; } }
// get's re-used for property parameters internal static void AppendHelpParameterList(StringBuilder result, ReadOnlyCollection <IParameter> parameters) { result.Append('('); if (parameters != null) { for (int i = 0; i < parameters.Count; i++) { if (i > 0) { result.Append(','); } IReturnType returnType = parameters[i].ReturnType; if (parameters[i].IsRef || parameters[i].IsOut) { result.Append("&"); } if (returnType == null) { result.Append("System.Void"); } else { result.Append(returnType.FullName); } for (int j = 0; j < returnType.ArrayDimensions; j++) { result.Append("["); int dimension = returnType.GetDimension(j); if (dimension > 0) { result.Append(new string (',', dimension)); } result.Append("]"); } result.Append(new string ('*', returnType.PointerNestingLevel)); } } result.Append(')'); }
public void Add(ProjectDom dom, IReturnType parameterType, IReturnType type) { // Console.WriteLine ("Add:" + parameterType +"\n\t->" + type); if (type == null || string.IsNullOrEmpty(type.FullName)) { return; } string name = parameterType.Name; bool contains = typeTable.ContainsKey(name); // when the type is already in the table use the type that is more general in the inheritance tree. if (contains && dom != null) { var t1 = dom.GetType(typeTable[name]); var t2 = dom.GetType(type); if (t1 != null && !dom.GetInheritanceTree(t1).Any(t => t.DecoratedFullName == t2.DecoratedFullName)) { return; } } DomReturnType newType = new DomReturnType(type.FullName); newType.ArrayDimensions = Math.Max(0, type.ArrayDimensions - parameterType.ArrayDimensions); newType.PointerNestingLevel = Math.Max(0, type.PointerNestingLevel - parameterType.PointerNestingLevel); newType.Type = type.Type; // May be anonymous type for (int i = 0; i < newType.ArrayDimensions; i++) { newType.SetDimension(i, parameterType.GetDimension(i)); } foreach (var generic in type.GenericArguments) { newType.AddTypeParameter(generic); } typeTable[name] = newType; }
public static void Write(BinaryWriter writer, INameEncoder nameTable, IReturnType returnType) { if (WriteNull(writer, returnType)) { return; } int index = DomReturnType.GetIndex(returnType); if (index >= 0) { writer.Write((byte)index); return; } writer.Write((byte)0xFF); WriteString(returnType.Namespace, writer, nameTable); writer.Write((uint)returnType.Parts.Count); foreach (ReturnTypePart part in returnType.Parts) { WriteString(part.Name, writer, nameTable); writer.Write(part.IsGenerated); writer.Write((uint)part.GenericArguments.Count); foreach (IReturnType rtp in part.GenericArguments) { Write(writer, nameTable, rtp); } } writer.Write(returnType.PointerNestingLevel); writer.Write(returnType.IsNullable); writer.Write(returnType.IsByRef); writer.Write(returnType.ArrayDimensions); for (int n = 0; n < returnType.ArrayDimensions; n++) { writer.Write(returnType.GetDimension(n)); } }
public override INode Visit(IReturnType type, IType contextType) { if (type.GenericArguments.Count == 0 && unit != null) { foreach (IUsing u in unit.Usings) { if (u.IsFromNamespace || u.Aliases.Count == 0 && contextType != null && u.Region.Contains(contextType.Location)) { continue; } foreach (KeyValuePair <string, IReturnType> alias in u.Aliases) { if (alias.Key == type.FullName) { return(Visit(alias.Value, contextType)); } } } } if (currentMethod != null) { IMethod method = null; if (currentMethod.IsOverride) { foreach (IType curType2 in db.GetInheritanceTree(contextType)) { foreach (IMethod curMethod in curType2.SearchMember(currentMethod.Name, true)) { if (!curMethod.IsOverride && curMethod.Parameters.Count == currentMethod.Parameters.Count && curMethod.TypeParameters.Count == currentMethod.TypeParameters.Count) { method = curMethod; break; } } if (method != null) { break; } } } if (method == null) { method = currentMethod; } int idx = currentMethod.GetTypeParameterIndex(type.Name); if (idx >= 0) { ITypeParameter t = method.TypeParameters [idx]; DomReturnType typeParameterReturnType = new DomReturnType(type.FullName); DomType constructedType = new InstantiatedParameterType(db, method, t); if (constructedType.BaseType == null) { constructedType.BaseType = DomReturnType.Object; } constructedType.SourceProjectDom = db; typeParameterReturnType.Type = constructedType; typeParameterReturnType.ArrayDimensions = type.ArrayDimensions; typeParameterReturnType.PointerNestingLevel = type.PointerNestingLevel; for (int i = 0; i < type.ArrayDimensions; i++) { typeParameterReturnType.SetDimension(i, type.GetDimension(i)); } return(typeParameterReturnType); } } IType lookupType = db.SearchType(unit, contextType, resolvePosition, type); if (visitAttribute && lookupType == null && type.Parts.Count > 0) { string oldName = type.Parts [type.Parts.Count - 1].Name; type.Parts [type.Parts.Count - 1].Name += "Attribute"; lookupType = db.SearchType(unit, contextType, resolvePosition, type); if (lookupType == null) { type.Parts [type.Parts.Count - 1].Name = oldName; } } if (lookupType == null) { unresolvedCount++; return(type); } List <IReturnTypePart> parts = new List <IReturnTypePart> (type.Parts.Count); IType curType = lookupType.DeclaringType; int typePart = 0; while (curType != null) { ReturnTypePart newPart = new ReturnTypePart { Name = curType.Name }; newPart.IsGenerated = true; for (int n = curType.TypeParameters.Count - 1; n >= 0; n--) { newPart.AddTypeParameter(new DomReturnType("?")); } if (typePart >= type.Parts.Count || (type.Parts [typePart].Name != newPart.Name || type.Parts [typePart].GenericArguments.Count != newPart.GenericArguments.Count)) { parts.Insert(0, newPart); typePart++; } curType = curType.DeclaringType; } foreach (ReturnTypePart part in type.Parts) { ReturnTypePart newPart = new ReturnTypePart(); newPart.Name = part.Name; foreach (IReturnType ga in part.GenericArguments) { newPart.AddTypeParameter((IReturnType)ga.AcceptVisitor(this, contextType)); } parts.Add(newPart); } DomReturnType rt = new DomReturnType(lookupType.Namespace, parts); // Make sure the whole type is resolved if (parts.Count > 1 && db.SearchType(unit, contextType, resolvePosition, rt) == null) { unresolvedCount++; return(type); } rt.PointerNestingLevel = type.PointerNestingLevel; rt.IsNullable = type.IsNullable; rt.ArrayDimensions = type.ArrayDimensions; for (int n = 0; n < type.ArrayDimensions; n++) { rt.SetDimension(n, type.GetDimension(n)); } return(db.GetSharedReturnType(rt)); }
ResolveResult CreateResult (ICompilationUnit unit, IReturnType type) { MemberResolveResult result = new MemberResolveResult (null); result.CallingType = resolver.CallingType; result.CallingMember = resolver.CallingMember; result.ResolvedType = type; result.UnresolvedType = type; if (unit != null && resolver.Dom != null && type != null && type.Type == null) { IType searchedType = resolver.SearchType (type); if (searchedType != null) { DomReturnType resType = new DomReturnType (searchedType); resType.ArrayDimensions = type.ArrayDimensions; for (int i = 0; i < type.ArrayDimensions; i++) { resType.SetDimension (i, type.GetDimension (i)); } resType.PointerNestingLevel = type.PointerNestingLevel; result.ResolvedType = resType; } } return result; }
public string Visit(IReturnType returnType, OutputSettings settings) { if (returnType.IsNullable && returnType.GenericArguments.Count == 1) { return(Visit(returnType.GenericArguments[0], settings) + "?"); } if (returnType.Type is AnonymousType) { return(returnType.Type.AcceptVisitor(this, settings)); } StringBuilder result = new StringBuilder(); if (!settings.UseNETTypeNames && netToCSharpTypes.ContainsKey(returnType.FullName)) { result.Append(settings.EmitName(returnType, netToCSharpTypes[returnType.FullName])); } else { if (settings.UseFullName && returnType.Namespace != null) { result.Append(settings.EmitName(returnType, Format(NormalizeTypeName(returnType.Namespace)))); } foreach (ReturnTypePart part in returnType.Parts) { if (part.IsGenerated) { continue; } if (!settings.UseFullName && part != returnType.Parts.LastOrDefault()) { continue; } if (result.Length > 0) { result.Append(settings.EmitName(returnType, ".")); } result.Append(settings.EmitName(returnType, Format(NormalizeTypeName(part.Name)))); if (settings.IncludeGenerics && part.GenericArguments.Count > 0) { result.Append(settings.Markup("<")); bool hideArrays = settings.HideArrayBrackets; settings.OutputFlags &= ~OutputFlags.HideArrayBrackets; for (int i = 0; i < part.GenericArguments.Count; i++) { if (i > 0) { result.Append(settings.Markup(settings.HideGenericParameterNames ? "," : ", ")); } if (!settings.HideGenericParameterNames) { result.Append(GetString(part.GenericArguments[i], settings)); } } if (hideArrays) { settings.OutputFlags |= OutputFlags.HideArrayBrackets; } result.Append(settings.Markup(">")); } } } if (!settings.HideArrayBrackets && returnType.ArrayDimensions > 0) { for (int i = 0; i < returnType.ArrayDimensions; i++) { result.Append(settings.Markup("[")); int dimension = returnType.GetDimension(i); if (dimension > 0) { result.Append(settings.Markup(new string (',', dimension))); } result.Append(settings.Markup("]")); } } return(result.ToString()); }
public static void Write (BinaryWriter writer, INameEncoder nameTable, IReturnType returnType) { if (WriteNull (writer, returnType)) return; int index = DomReturnType.GetIndex (returnType); if (index >= 0) { writer.Write ((byte)index); return; } writer.Write ((byte)0xFF); WriteString (returnType.Namespace, writer, nameTable); writer.Write ((uint) returnType.Parts.Count); foreach (ReturnTypePart part in returnType.Parts) { WriteString (part.Name, writer, nameTable); writer.Write (part.IsGenerated); writer.Write ((uint) part.GenericArguments.Count); foreach (IReturnType rtp in part.GenericArguments) Write (writer, nameTable, rtp); } writer.Write (returnType.PointerNestingLevel); writer.Write (returnType.IsNullable); writer.Write (returnType.IsByRef); writer.Write (returnType.ArrayDimensions); for (int n=0; n<returnType.ArrayDimensions; n++) writer.Write (returnType.GetDimension (n)); }