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