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 virtual IType GetType(IReturnType returnType)
{
if (returnType == null)
{
return(null);
}
if (returnType.ArrayDimensions > 0)
{
DomReturnType newType = new DomReturnType(returnType.FullName);
newType.ArrayDimensions = returnType.ArrayDimensions - 1;
for (int i = 0; i < newType.ArrayDimensions; i++)
{
newType.SetDimension(i, returnType.ArrayDimensions - 1);
}
newType.PointerNestingLevel = returnType.PointerNestingLevel;
return(GetArrayType(newType));
}
IType type = returnType.Type ?? GetType(((DomReturnType)returnType).DecoratedFullName, returnType.GenericArguments, true, true);
if (type != null)
{
if (type.Kind == TypeKind.GenericInstantiation || type.Kind == TypeKind.GenericParameter)
{
return(type);
}
if (!returnType.Parts.Any(part => part.GenericArguments.Count != 0))
{
return(type);
}
List <IReturnType> aggregatedGenerics = new List <IReturnType> ();
foreach (IReturnTypePart part in returnType.Parts)
{
aggregatedGenerics.AddRange(part.GenericArguments);
}
return(CreateInstantiatedGenericType(type, aggregatedGenerics));
}
return(type);
/*
* IReturnTypePart part = returnType.Parts [0];
* string name = !string.IsNullOrEmpty (returnType.Namespace) ? returnType.Namespace + "." + part.Name : part.Name;
* IType ptype = GetType (name, part.GenericArguments, true, true);
* if (ptype == null)
* return null;
* for (int n=1; n < returnType.Parts.Count; n++) {
* part = returnType.Parts [n];
* ptype = SearchInnerType (ptype, part.Name, part.GenericArguments.Count, true);
* if (ptype != null)
* break;
* if (ptype == null)
* return null;
* if (part.GenericArguments.Count > 0)
* ptype = CreateInstantiatedGenericType (ptype, part.GenericArguments);
* }
* return ptype;
*/
}
static IReturnType ConvertTypeReference(TypeReference typeRef)
{
if (typeRef == null)
{
return(null);
}
DomReturnType result = new DomReturnType(typeRef.Type);
foreach (TypeReference genericArgument in typeRef.GenericTypes)
{
result.AddTypeParameter(ConvertTypeReference(genericArgument));
}
result.PointerNestingLevel = typeRef.PointerNestingLevel;
if (typeRef.IsArrayType)
{
result.ArrayDimensions = typeRef.RankSpecifier.Length;
for (int i = 0; i < typeRef.RankSpecifier.Length; i++)
{
result.SetDimension(i, typeRef.RankSpecifier[i]);
}
}
return(result);
}
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));
}
internal static void AddType (ProjectDom dom, List<object> result, IReturnType returnType, IMember callingMember, bool showStatic)
{
if (returnType == null || returnType.FullName == "System.Void")
return;
if (returnType.ArrayDimensions > 0) {
DomReturnType elementType = new DomReturnType (returnType.FullName);
elementType.ArrayDimensions = returnType.ArrayDimensions - 1;
for (int i = 0; i < elementType.ArrayDimensions; i++) {
elementType.SetDimension (i, returnType.ArrayDimensions - 1);
}
elementType.PointerNestingLevel = returnType.PointerNestingLevel;
AddType (dom, result, dom.GetArrayType (elementType), callingMember, showStatic);
return;
}
IType type = dom.GetType (returnType);
AddType (dom, result, type, callingMember, showStatic);
}
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;
}
static IReturnType ConvertTypeReference (TypeReference typeRef)
{
if (typeRef == null)
return null;
DomReturnType result = new DomReturnType (typeRef.Type);
foreach (TypeReference genericArgument in typeRef.GenericTypes) {
result.AddTypeParameter (ConvertTypeReference (genericArgument));
}
result.PointerNestingLevel = typeRef.PointerNestingLevel;
if (typeRef.IsArrayType) {
result.ArrayDimensions = typeRef.RankSpecifier.Length;
for (int i = 0; i < typeRef.RankSpecifier.Length; i++) {
result.SetDimension (i, typeRef.RankSpecifier[i]);
}
}
return result;
}
public virtual IType GetType (IReturnType returnType)
{
if (returnType == null)
return null;
if (returnType.ArrayDimensions > 0) {
DomReturnType newType = new DomReturnType (returnType.FullName);
newType.ArrayDimensions = returnType.ArrayDimensions - 1;
for (int i = 0; i < newType.ArrayDimensions; i++) {
newType.SetDimension (i, returnType.ArrayDimensions - 1);
}
newType.PointerNestingLevel = returnType.PointerNestingLevel;
return GetArrayType (newType);
}
IType type = returnType.Type ?? GetType (((DomReturnType)returnType).DecoratedFullName, returnType.GenericArguments, true, true);
if (type != null) {
if (type.Kind == TypeKind.GenericInstantiation || type.Kind == TypeKind.GenericParameter)
return type;
if (!returnType.Parts.Any (part => part.GenericArguments.Count != 0))
return type;
List<IReturnType> aggregatedGenerics = new List<IReturnType> ();
foreach (IReturnTypePart part in returnType.Parts) {
aggregatedGenerics.AddRange (part.GenericArguments);
}
return CreateInstantiatedGenericType (type, aggregatedGenerics);
}
return type;
/*
IReturnTypePart part = returnType.Parts [0];
string name = !string.IsNullOrEmpty (returnType.Namespace) ? returnType.Namespace + "." + part.Name : part.Name;
IType ptype = GetType (name, part.GenericArguments, true, true);
if (ptype == null)
return null;
for (int n=1; n < returnType.Parts.Count; n++) {
part = returnType.Parts [n];
ptype = SearchInnerType (ptype, part.Name, part.GenericArguments.Count, true);
if (ptype != null)
break;
if (ptype == null)
return null;
if (part.GenericArguments.Count > 0)
ptype = CreateInstantiatedGenericType (ptype, part.GenericArguments);
}
return ptype;
*/
}
