public static List <string> GetResolveableNamespaces(RefactoringOptions options, out bool resolveDirect)
{
IReturnType returnType = null;
INRefactoryASTProvider astProvider = RefactoringService.GetASTProvider(DesktopService.GetMimeTypeForUri(options.Document.FileName));
if (options.ResolveResult != null && options.ResolveResult.ResolvedExpression != null)
{
if (astProvider != null)
{
returnType = astProvider.ParseTypeReference(options.ResolveResult.ResolvedExpression.Expression).ConvertToReturnType();
}
if (returnType == null)
{
returnType = DomReturnType.GetSharedReturnType(options.ResolveResult.ResolvedExpression.Expression);
}
}
List <string> namespaces;
if (options.ResolveResult is UnresolvedMemberResolveResult)
{
namespaces = new List <string> ();
UnresolvedMemberResolveResult unresolvedMemberResolveResult = options.ResolveResult as UnresolvedMemberResolveResult;
IType type = unresolvedMemberResolveResult.TargetResolveResult != null?options.Dom.GetType(unresolvedMemberResolveResult.TargetResolveResult.ResolvedType) : null;
if (type != null)
{
List <IType> allExtTypes = DomType.GetAccessibleExtensionTypes(options.Dom, null);
foreach (ExtensionMethod method in type.GetExtensionMethods(allExtTypes, unresolvedMemberResolveResult.MemberName))
{
string ns = method.OriginalMethod.DeclaringType.Namespace;
if (!namespaces.Contains(ns) && !options.Document.CompilationUnit.Usings.Any(u => u.Namespaces.Contains(ns)))
{
namespaces.Add(ns);
}
}
}
resolveDirect = false;
}
else
{
namespaces = new List <string> (options.Dom.ResolvePossibleNamespaces(returnType));
resolveDirect = true;
}
for (int i = 0; i < namespaces.Count; i++)
{
for (int j = i + 1; j < namespaces.Count; j++)
{
if (namespaces[j] == namespaces[i])
{
namespaces.RemoveAt(j);
j--;
}
}
}
return(namespaces);
}
public override object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)
{
if (resolver.CallingType == null)
{
return(CreateResult(DomReturnType.Void));
}
ThisResolveResult result = new ThisResolveResult();
result.CallingType = resolver.CallingType;
result.CallingMember = resolver.CallingMember;
result.UnresolvedType = result.ResolvedType = DomReturnType.GetSharedReturnType(new DomReturnType(resolver.CallingType));
return(result);
}
public static IReturnType ReadReturnType(BinaryReader reader, INameDecoder nameTable)
{
if (ReadNull(reader))
{
return(null);
}
byte index = reader.ReadByte();
if (index < 0xFF)
{
return(DomReturnType.GetSharedReturnType(index));
}
string ns = ReadString(reader, nameTable);
List <IReturnTypePart> parts = new List <IReturnTypePart> ();
uint partCount = ReadUInt(reader, 500);
while (partCount-- > 0)
{
ReturnTypePart part = new ReturnTypePart();
parts.Add(part);
part.Name = ReadString(reader, nameTable);
part.IsGenerated = reader.ReadBoolean();
uint arguments = ReadUInt(reader, 1000);
while (arguments-- > 0)
{
part.AddTypeParameter(ReadReturnType(reader, nameTable));
}
}
DomReturnType result = new DomReturnType(ns, parts);
result.PointerNestingLevel = reader.ReadInt32();
result.IsNullable = reader.ReadBoolean();
result.IsByRef = reader.ReadBoolean();
int arrayDimensions = reader.ReadInt32();
int[] dims = new int [arrayDimensions];
for (int n = 0; n < arrayDimensions; n++)
{
dims [n] = reader.ReadInt32();
}
result.SetDimensions(dims);
return(result);
}
internal IReturnType GetSharedReturnType(IReturnType rt)
{
string id = rt.ToInvariantString();
IReturnType s;
if (!returnTypeCache.TryGetValue(id, out s))
{
s = DomReturnType.GetSharedReturnType(rt, true);
if (s == null)
{
s = rt;
returnTypeCache [id] = rt;
}
}
return(s);
}
internal IReturnType GetSharedReturnType(IReturnType rt)
{
string id = rt.ToInvariantString();
IReturnType s;
if (returnTypeCache.TryGetValue(id, out s))
{
return(s);
}
s = DomReturnType.GetSharedReturnType(rt);
if (object.ReferenceEquals(s, rt))
{
returnTypeCache [id] = rt;
}
return(s);
}
internal IReturnType GetSharedReturnType(DomReturnType rt)
{
return(DomReturnType.GetSharedReturnType(rt));
}
