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