// Internal for unit tests only.
internal MergedNamespaceDeclaration CalculateMergedRoot(CSharpCompilation compilation)
{
var oldRoot = _cache.MergedRoot.Value;
if (_latestLazyRootDeclaration == null)
{
return(oldRoot);
}
else if (oldRoot == null)
{
return(MergedNamespaceDeclaration.Create(_latestLazyRootDeclaration.Value));
}
else
{
var oldRootDeclarations = oldRoot.Declarations;
var builder = ArrayBuilder <SingleNamespaceDeclaration> .GetInstance(oldRootDeclarations.Length + 1);
builder.AddRange(oldRootDeclarations);
builder.Add(_latestLazyRootDeclaration.Value);
// Sort the root namespace declarations to match the order of SyntaxTrees.
if (compilation != null)
{
builder.Sort(new RootNamespaceLocationComparer(compilation));
}
return(MergedNamespaceDeclaration.Create(builder.ToImmutableAndFree()));
}
}
public Cache(DeclarationTable table)
{
this.MergedRoot = new Lazy <MergedNamespaceDeclaration>(
() => MergedNamespaceDeclaration.Create(table._allOlderRootDeclarations.InInsertionOrder.AsImmutable <SingleNamespaceDeclaration>()));
this.TypeNames = new Lazy <ISet <string> >(
() => GetTypeNames(this.MergedRoot.Value));
this.NamespaceNames = new Lazy <ISet <string> >(
() => GetNamespaceNames(this.MergedRoot.Value));
this.ReferenceDirectives = new Lazy <ImmutableArray <ReferenceDirective> >(
() => MergedRoot.Value.Declarations.OfType <RootSingleNamespaceDeclaration>().SelectMany(r => r.ReferenceDirectives).AsImmutable());
}
private ImmutableArray <MergedNamespaceOrTypeDeclaration> MakeChildren()
{
ArrayBuilder <SingleNamespaceDeclaration> namespaces = null;
ArrayBuilder <SingleTypeDeclaration> types = null;
bool allNamespacesHaveSameName = true;
bool allTypesHaveSameIdentity = true;
foreach (var decl in _declarations)
{
foreach (var child in decl.Children)
{
// it is either a type (more likely)
var asType = child as SingleTypeDeclaration;
if (asType != null)
{
// handle types
if (types == null)
{
types = ArrayBuilder <SingleTypeDeclaration> .GetInstance();
}
else if (allTypesHaveSameIdentity && !asType.Identity.Equals(types[0].Identity))
{
allTypesHaveSameIdentity = false;
}
types.Add(asType);
continue;
}
// or it is a namespace
var asNamespace = child as SingleNamespaceDeclaration;
if (asNamespace != null)
{
// handle namespace
if (namespaces == null)
{
namespaces = ArrayBuilder <SingleNamespaceDeclaration> .GetInstance();
}
else if (allNamespacesHaveSameName && !asNamespace.Name.Equals(namespaces[0].Name))
{
allNamespacesHaveSameName = false;
}
namespaces.Add(asNamespace);
continue;
}
// Not sure if we can get here, perhaps, if we have errors,
// but we care only about types and namespaces anyways.
}
}
var children = ArrayBuilder <MergedNamespaceOrTypeDeclaration> .GetInstance();
if (namespaces != null)
{
if (allNamespacesHaveSameName)
{
children.Add(MergedNamespaceDeclaration.Create(namespaces.ToImmutableAndFree()));
}
else
{
var namespaceGroups = namespaces.ToDictionary(n => n.Name, StringOrdinalComparer.Instance);
namespaces.Free();
foreach (var namespaceGroup in namespaceGroups.Values)
{
children.Add(MergedNamespaceDeclaration.Create(namespaceGroup));
}
}
}
if (types != null)
{
if (allTypesHaveSameIdentity)
{
children.Add(new MergedTypeDeclaration(types.ToImmutableAndFree()));
}
else
{
var typeGroups = types.ToDictionary(t => t.Identity);
types.Free();
foreach (var typeGroup in typeGroups.Values)
{
children.Add(new MergedTypeDeclaration(typeGroup));
}
}
}
return(children.ToImmutableAndFree());
}
