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