public sealed override ImmutableArray <Symbol> GetMembers(string name) { EnsureAllMembersLoaded(); PENestedNamespaceSymbol ns = null; ImmutableArray <PENamedTypeSymbol> t; if (lazyNamespaces.TryGetValue(name, out ns)) { if (lazyTypes.TryGetValue(name, out t)) { // TODO - Eliminate the copy by storing all members and type members instead of non-type and type members? return(StaticCast <Symbol> .From(t).Add(ns)); } else { return(ImmutableArray.Create <Symbol>(ns)); } } else if (lazyTypes.TryGetValue(name, out t)) { return(StaticCast <Symbol> .From(t)); } return(ImmutableArray <Symbol> .Empty); }
public sealed override ImmutableArray <Symbol> GetMembers(string name) { EnsureAllMembersLoaded(); PENestedNamespaceSymbol ns = null; ImmutableArray <PENamedTypeSymbol> t; #if XSHARP // When we have siblings then collect all members from all siblings if (!siblings.IsEmpty) { var builder = ArrayBuilder <Symbol> .GetInstance(); foreach (var sib in siblings) { sib.EnsureAllMembersLoaded(); if (sib.lazyNamespaces.TryGetValue(name, out ns)) { builder.AddRange(ns); } if (sib.lazyTypes.TryGetValue(name, out t)) { builder.AddRange(t); } } return(builder.ToImmutableAndFree()); } #endif if (lazyNamespaces.TryGetValue(name, out ns)) { if (lazyTypes.TryGetValue(name, out t)) { // TODO - Eliminate the copy by storing all members and type members instead of non-type and type members? return(StaticCast <Symbol> .From(t).Add(ns)); } else { return(ImmutableArray.Create <Symbol>(ns)); } } else if (lazyTypes.TryGetValue(name, out t)) { return(StaticCast <Symbol> .From(t)); } return(ImmutableArray <Symbol> .Empty); }
/// <summary> /// Create symbols for nested namespaces and initialize namespaces map. /// </summary> private void LazyInitializeNamespaces( IEnumerable <KeyValuePair <string, IEnumerable <IGrouping <string, TypeDefinitionHandle> > > > childNamespaces) { if (this.lazyNamespaces == null) { var namespaces = new Dictionary <string, PENestedNamespaceSymbol>(StringOrdinalComparer.Instance); foreach (var child in childNamespaces) { var c = new PENestedNamespaceSymbol(child.Key, this, child.Value); namespaces.Add(c.Name, c); } Interlocked.CompareExchange(ref this.lazyNamespaces, namespaces, null); } }
/// <summary> /// Create symbols for nested namespaces and initialize namespaces map. /// </summary> private void LazyInitializeNamespaces( IEnumerable<KeyValuePair<string, IEnumerable<IGrouping<string, TypeDefinitionHandle>>>> childNamespaces) { if (this.lazyNamespaces == null) { var namespaces = new Dictionary<string, PENestedNamespaceSymbol>(StringOrdinalComparer.Instance); foreach (var child in childNamespaces) { var c = new PENestedNamespaceSymbol(child.Key, this, child.Value); namespaces.Add(c.Name, c); } Interlocked.CompareExchange(ref this.lazyNamespaces, namespaces, null); } }
/// <summary> /// Create symbols for nested namespaces and initialize namespaces map. /// </summary> private void LazyInitializeNamespaces( IEnumerable <KeyValuePair <string, IEnumerable <IGrouping <string, TypeDefinitionHandle> > > > childNamespaces) { if (this.lazyNamespaces == null) { #if XSHARP // Keep track of namespaces that only differ in casing. // we link these namespaces with eachother so the type // lookup or member lookup on one returns the elements of all var namespaces = new Dictionary <string, PENestedNamespaceSymbol>(XSharpString.Comparer); var duplicates = new Dictionary <string, List <PENestedNamespaceSymbol> >(XSharpString.Comparer); var list = new List <PENestedNamespaceSymbol>(); #else var namespaces = new Dictionary <string, PENestedNamespaceSymbol>(StringOrdinalComparer.Instance); #endif foreach (var child in childNamespaces) { var c = new PENestedNamespaceSymbol(child.Key, this, child.Value); #if XSHARP if (!namespaces.ContainsKey(c.Name)) { namespaces.Add(c.Name, c); } else { List <PENestedNamespaceSymbol> dups; if (!duplicates.ContainsKey(c.Name)) { dups = new List <PENestedNamespaceSymbol>() { namespaces[c.Name] }; duplicates.Add(c.Name, dups); } else { dups = duplicates[c.Name]; } dups.Add(c); } list.Add(c); #else namespaces.Add(c.Name, c); #endif } Interlocked.CompareExchange(ref this.lazyNamespaces, namespaces, null); #if XSHARP // link the duplicate children with eachother foreach (var dup in duplicates) { foreach (var ns in dup.Value) { ns.siblings = dup.Value.ToImmutableArray(); } } Interlocked.CompareExchange(ref this.lazyNamespacesList, list, null); #endif } }