private Symbol CreateMockSymbol(NamespaceExtent extent, XElement xel)
{
Symbol result;
var childSymbols = from childElement in xel.Elements()
select CreateMockSymbol(extent, childElement);
string name = xel.Attribute("name").Value;
switch (xel.Name.LocalName)
{
case "ns":
result = new MockNamespaceSymbol(name, extent, childSymbols);
break;
case "class":
result = new MockNamedTypeSymbol(name, childSymbols, TypeKind.Class);
break;
default:
throw new InvalidOperationException("unexpected xml element");
}
foreach (IMockSymbol child in childSymbols)
{
child.SetContainer(result);
}
return(result);
}
public MockNamespaceSymbol(
string name,
NamespaceExtent extent,
IEnumerable <Symbol> children
)
{
_name = name;
_extent = extent;
_children = children;
}
public void TestNamespaceExtent()
{
AssemblySymbol assem1 = new MockAssemblySymbol("foo");
NamespaceExtent ne1 = new NamespaceExtent(assem1);
Assert.Equal(ne1.Kind, NamespaceKind.Assembly);
Assert.Same(ne1.Assembly, assem1);
CSharpCompilation compilation = CSharpCompilation.Create("Test");
NamespaceExtent ne2 = new NamespaceExtent(compilation);
Assert.IsType <CSharpCompilation>(ne2.Compilation);
Assert.Throws <InvalidOperationException>(() => ne1.Compilation);
}
// Constructor. Use static Create method to create instances.
private MergedNamespaceSymbol(NamespaceExtent extent, NamespaceSymbol containingNamespace, ImmutableArray<NamespaceSymbol> namespacesToMerge, string nameOpt)
{
this.extent = extent;
this.namespacesToMerge = namespacesToMerge;
this.containingNamespace = containingNamespace;
this.cachedLookup = new CachingDictionary<string, Symbol>(SlowGetChildrenOfName, SlowGetChildNames, EqualityComparer<string>.Default);
this.nameOpt = nameOpt;
#if DEBUG
// We shouldn't merged namespaces that are already merged.
foreach (NamespaceSymbol ns in namespacesToMerge)
{
Debug.Assert(ns.ConstituentNamespaces.Length == 1);
}
#endif
}
/// <summary>
/// Create a possibly merged namespace symbol. If only a single namespace is passed it, it
/// is just returned directly. If two or more namespaces are passed in, then a new merged
/// namespace is created with the given extent and container.
/// </summary>
/// <param name="extent">The namespace extent to use, IF a merged namespace is created.</param>
/// <param name="containingNamespace">The containing namespace to used, IF a merged
/// namespace is created.</param>
/// <param name="namespacesToMerge">One or more namespaces to merged. If just one, then it
/// is returned. The merged namespace symbol may hold onto the array.</param>
/// <param name="nameOpt">An optional name to give the resulting namespace.</param>
/// <returns>A namespace symbol representing the merged namespace.</returns>
internal static NamespaceSymbol Create(
NamespaceExtent extent,
NamespaceSymbol containingNamespace,
ImmutableArray<NamespaceSymbol> namespacesToMerge,
string nameOpt = null)
{
// Currently, if we are just merging 1 namespace, we just return the namespace itself.
// This is by far the most efficient, because it means that we don't create merged
// namespaces (which have a fair amount of memory overhead) unless there is actual
// merging going on. However, it means that the child namespace of a Compilation extent
// namespace may be a Module extent namespace, and the containing of that module extent
// namespace will be another module extent namespace. This is basically no different
// than type members of namespaces, so it shouldn't be TOO unexpected.
// EDMAURER if the caller is supplying a name, then produce the merged namespace with
// the new name even if only a single namespace was provided. This behavior was introduced
// to support nice extern alias error reporting.
Debug.Assert(namespacesToMerge.Length != 0);
return (namespacesToMerge.Length == 1 && nameOpt == null)
? namespacesToMerge[0]
: new MergedNamespaceSymbol(extent, containingNamespace, namespacesToMerge, nameOpt);
}
public MockNamespaceSymbol(string name, NamespaceExtent extent, IEnumerable<Symbol> children)
{
this.name = name;
this.extent = extent;
this.children = children;
}
public MockNamespaceSymbol(string name, NamespaceExtent extent, IEnumerable <Symbol> children)
{
this.name = name;
this.extent = extent;
this.children = children;
}
public MockNamespaceSymbol(string name, NamespaceExtent extent, IEnumerable<Symbol> children)
{
_name = name;
_extent = extent;
_children = children;
}
private Symbol CreateMockSymbol(NamespaceExtent extent, XElement xel)
{
Symbol result;
var childSymbols = from childElement in xel.Elements()
select CreateMockSymbol(extent, childElement);
string name = xel.Attribute("name").Value;
switch (xel.Name.LocalName)
{
case "ns":
result = new MockNamespaceSymbol(name, extent, childSymbols);
break;
case "class":
result = new MockNamedTypeSymbol(name, childSymbols, TypeKind.Class);
break;
default:
throw new ApplicationException("unexpected xml element");
}
foreach (IMockSymbol child in childSymbols)
{
child.SetContainer(result);
}
return result;
}
public void TestNamespaceExtent()
{
AssemblySymbol assem1 = new MockAssemblySymbol("foo");
NamespaceExtent ne1 = new NamespaceExtent(assem1);
Assert.Equal(ne1.Kind, NamespaceKind.Assembly);
Assert.Same(ne1.Assembly, assem1);
CSharpCompilation compilation = CSharpCompilation.Create("Test");
NamespaceExtent ne2 = new NamespaceExtent(compilation);
Assert.IsType<CSharpCompilation>(ne2.Compilation);
Assert.Throws<InvalidOperationException>(() => ne1.Compilation);
}
