private static TypeResolverNamespace CreateGenericParameterNamespace(IGenericMember member)
{
var originalPathLength = member.FullName.PathLength;
var result = new TypeResolverNamespace();
foreach (var genericParam in member.GenericParameters)
{
result.Add(genericParam.FullName.Slice(originalPathLength), genericParam);
}
return(result);
}
private static TypeResolverNamespace CreateNestedTypeNamespace(IType type)
{
var originalPathLength = type.FullName.PathLength;
var result = new TypeResolverNamespace();
foreach (var nestedType in type.NestedTypes)
{
result.Add(nestedType.FullName.Slice(originalPathLength), nestedType);
}
return(result);
}
/// <summary>
/// Tries to find a child whose full name corresponds to the concatenation
/// of this namespace's full name and a given qualified name.
/// </summary>
/// <param name="fullName">The name to look for.</param>
/// <param name="result">
/// A namespace whose name equals the concatenation of this namespace's
/// full name and <paramref name="fullName"/>, provided that there is
/// such a namespace.
/// </param>
/// <returns>
/// <c>true</c> if a (non-empty) namespace with name
/// <paramref name="fullName"/> can be found; otherwise, <c>false</c>.
/// </returns>
public bool TryResolveNamespace(QualifiedName fullName, out TypeResolverNamespace result)
{
if (fullName.IsEmpty)
{
result = this;
return(true);
}
TypeResolverNamespace childNamespace;
if (namespaceMap.TryGetValue(fullName.Qualifier, out childNamespace))
{
return(childNamespace.TryResolveNamespace(fullName.Name, out result));
}
else
{
result = null;
return(false);
}
}
internal void Add(QualifiedName path, IType type)
{
var qualifier = path.Qualifier;
if (path.IsQualified)
{
TypeResolverNamespace subNamespace;
if (!namespaceMap.TryGetValue(qualifier, out subNamespace))
{
subNamespace = new TypeResolverNamespace();
namespaceMap[qualifier] = subNamespace;
}
subNamespace.Add(path.Name, type);
}
else if (typeSet.Add(type))
{
GetOrCreateBag(typeMap, qualifier).Add(type);
GetOrCreateBag(impreciseTypeMap, ToImpreciseName(qualifier)).Add(type);
}
}
/// <summary>
/// Tries to find a namespace with a particular full name.
/// </summary>
/// <param name="fullName">The name to look for.</param>
/// <param name="result">
/// A namespace with name <paramref name="fullName"/>, if one can be found.
/// </param>
/// <returns>
/// <c>true</c> if a (non-empty) namespace with name
/// <paramref name="fullName"/> can be found; otherwise, <c>false</c>.
/// </returns>
public bool TryResolveNamespace(
QualifiedName fullName,
out TypeResolverNamespace result)
{
return(resolver.TryResolveNamespace(fullName, out result));
}
private static IReadOnlyList <IType> ResolveImprecise(
TypeResolverNamespace ns,
string name)
{
return(ns.ResolveTypes(name));
}
private static IReadOnlyList <IType> ResolvePrecise(
TypeResolverNamespace ns,
UnqualifiedName name)
{
return(ns.ResolveTypes(name));
}
