private static void GetItemsFromConflictingTypes(
INamespaceSymbol containingNamespaceSymbol,
ConflictNameNode conflictTypeNodes,
ArrayBuilder <SerializableImportCompletionItem> builder,
ITypeSymbol receiverTypeSymbol,
SemanticModel semanticModel,
int position,
StatisticCounter counter)
{
Debug.Assert(!conflictTypeNodes.NamespaceAndMethodNames.HasValue);
foreach (var child in conflictTypeNodes.Children.Values)
{
if (child.NamespaceAndMethodNames == null)
{
var childNamespace = containingNamespaceSymbol.GetMembers(child.Name).OfType <INamespaceSymbol>().FirstOrDefault();
if (childNamespace != null)
{
GetItemsFromConflictingTypes(childNamespace, child, builder, receiverTypeSymbol, semanticModel, position, counter);
}
}
else
{
var types = containingNamespaceSymbol.GetMembers(child.Name).OfType <INamedTypeSymbol>();
foreach (var type in types)
{
var(namespaceName, methodNames) = child.NamespaceAndMethodNames.Value;
GetItemsFromTypeContainsPotentialMatches(type, namespaceName, methodNames, receiverTypeSymbol, semanticModel, position, counter, builder);
}
}
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
if (filterByAssemblyName && symbol.ContainingAssembly != null && symbol.ContainingAssembly.Name != assemblyName)
{
return;
}
var(isNamespace, isType) = allowedNamespaces.IsSymbolInTree(symbol);
if (isNamespace)
{
foreach (var memeber in symbol.GetMembers().OfType <INamespaceSymbol>())
{
memeber.Accept(this);
}
}
if (isType)
{
foreach (var memeber in symbol.GetMembers().OfType <ITypeSymbol>())
{
memeber.Accept(this);
}
}
}
public static IEnumerable <ITypeSymbol> GetTypeSymbols(this INamespaceSymbol namespaceSymbol)
{
if (namespaceSymbol == null)
{
throw new ArgumentNullException(nameof(namespaceSymbol));
}
return
(namespaceSymbol
.GetMembers()
.OfType <ITypeSymbol>()
.Union(namespaceSymbol.GetNamespaceMembers().SelectMany(x => x.GetTypeSymbols()))
.Union(namespaceSymbol.GetMembers().OfType <ITypeSymbol>().SelectMany(x => x.GetTypeSymbols())));
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
foreach (var namespaceOrTypeSymbol in symbol.GetMembers())
{
Visit(namespaceOrTypeSymbol);
}
}
/// <summary>
/// Construct a new NamespaceApiView instance, represented by the provided symbol.
/// </summary>
/// <param name="symbol">The symbol representing the namespace.</param>
public NamespaceApiView(INamespaceSymbol symbol)
{
this.Name = symbol.ToDisplayString();
this.Id = symbol.ToDisplayString();
List <NamedTypeApiView> namedTypes = new List <NamedTypeApiView>();
List <NamespaceApiView> namespaces = new List <NamespaceApiView>();
foreach (var memberSymbol in symbol.GetMembers().OfType <INamespaceOrTypeSymbol>())
{
if (memberSymbol.DeclaredAccessibility != Accessibility.Public)
{
continue;
}
if (memberSymbol is INamedTypeSymbol nt)
{
namedTypes.Add(new NamedTypeApiView(nt));
}
else if (memberSymbol is INamespaceSymbol ns)
{
namespaces.Add(new NamespaceApiView(ns));
}
}
this.NamedTypes = namedTypes.ToArray();
this.Namespaces = namespaces.ToArray();
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
foreach (var member in symbol.GetMembers())
{
member.Accept(this);
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
foreach (INamespaceOrTypeSymbol sym in symbol.GetMembers())
{
sym.Accept(this);
}
}
// This can be removed once changes in https://github.com/dotnet/roslyn/pull/15494 are merged and deployed
private string GetNamespaceDocumentationCommentXml(INamespaceSymbol symbol)
{
// Try and get comments applied to the namespace
TextWriter writer = new StringWriter();
CancellationToken ct = new CancellationToken();
object documentationCompiler = Activator.CreateInstance(_documentationCommentCompiler, BindingFlags.Instance | BindingFlags.NonPublic, null, new object[]
{
(string)null,
_compilation,
writer,
(SyntaxTree)null,
(TextSpan?)null,
true,
true,
null,
ct
}, null);
_documentationCommentCompilerDefaultVisit.Invoke(documentationCompiler, new object[] { symbol });
string docs = writer.ToString();
// Fall back to looking for a NamespaceDoc class
if (string.IsNullOrEmpty(docs))
{
INamespaceOrTypeSymbol namespaceDoc = symbol.GetMembers("NamespaceDoc").FirstOrDefault();
if (namespaceDoc != null)
{
return(namespaceDoc.GetDocumentationCommentXml(expandIncludes: true));
}
}
return(docs ?? string.Empty);
}
private bool BindsWithoutErrors(
INamespaceSymbol ns,
string?rightName,
bool isAttributeName
)
{
// If there was no name on the right, then this binds without any problems.
if (rightName == null)
{
return(true);
}
// Otherwise, see if the namespace we will bind this contains a member with the same
// name as the name on the right.
var types = ns.GetMembers(rightName);
if (types.Any())
{
return(true);
}
if (!isAttributeName)
{
return(false);
}
return(BindsWithoutErrors(ns, rightName + "Attribute", isAttributeName: false));
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
foreach (var typeSymbol in symbol.GetMembers())
{
typeSymbol.Accept(this);
}
}
public static IEnumerable <INamedTypeSymbol> GetAllTypes(this INamespaceSymbol @namespace, CancellationToken cancellationToken)
{
Queue <INamespaceOrTypeSymbol> symbols = new Queue <INamespaceOrTypeSymbol>();
symbols.Enqueue(@namespace);
while (symbols.Count > 0)
{
cancellationToken.ThrowIfCancellationRequested();
INamespaceOrTypeSymbol namespaceOrTypeSymbol = symbols.Dequeue();
INamespaceSymbol namespaceSymbol = namespaceOrTypeSymbol as INamespaceSymbol;
if (namespaceSymbol == null)
{
INamedTypeSymbol typeSymbol = (INamedTypeSymbol)namespaceOrTypeSymbol;
Array.ForEach(typeSymbol.GetTypeMembers().ToArray(), symbols.Enqueue);
yield return(typeSymbol);
}
else
{
Array.ForEach(namespaceSymbol.GetMembers().ToArray(), symbols.Enqueue);
}
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
// Add to the namespace symbol cache
string displayName = symbol.GetDisplayName();
ConcurrentHashSet <INamespaceSymbol> symbols = _namespaceDisplayNameToSymbols.GetOrAdd(displayName, _ => new ConcurrentHashSet <INamespaceSymbol>());
symbols.Add(symbol);
// Create the document (but not if none of the members would be included)
if (ShouldIncludeSymbol(symbol, x => _symbolPredicate == null || x.GetMembers().Any(m => _symbolPredicate(m, _compilation))))
{
_namespaceDisplayNameToDocument.AddOrUpdate(
displayName,
_ => AddNamespaceDocument(symbol, true),
(_, existing) =>
{
// There's already a document for this symbol display name, add it to the symbol-to-document cache
_symbolToDocument.TryAdd(symbol, existing);
return(existing);
});
}
// Descend if not finished, regardless if this namespace was included
if (!_finished)
{
Parallel.ForEach(symbol.GetMembers(), s => s.Accept(this));
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
_output.AppendLine(new string(' ', 2 * _indent) + symbol.GetType().Name + " " + symbol.Name);
_indent++;
VisitChildren(symbol.GetMembers());
_indent--;
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
foreach (var member in symbol.GetMembers())
{
Visit(member);
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
foreach (INamespaceOrTypeSymbol member in symbol.GetMembers())
{
this.Visit(member);
}
base.VisitNamespace(symbol);
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
foreach (var member in symbol.GetMembers())
{
this.context.CancellationToken.ThrowIfCancellationRequested();
member.Accept(this);
}
}
public override int VisitNamespace(INamespaceSymbol symbol, StringBuilder argument)
{
argument.AppendLine(new string(' ', 2 * _indent) + symbol.GetType().Name + " " + symbol.Name);
_indent++;
VisitChildren(symbol.GetMembers(), argument);
_indent--;
return(_indent);
}
/// <inheritdoc />
public override void VisitNamespace(INamespaceSymbol symbol)
{
Visit(symbol);
foreach (var member in symbol.GetMembers())
{
member.Accept(this);
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
Console.WriteLine(symbol);
foreach (var childSymbol in symbol.GetMembers())
{
childSymbol.Accept(this);
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
foreach (var s in symbol.GetMembers())
{
s.Accept(this);
}
//Parallel.ForEach(symbol.GetMembers(), s => s.Accept(this));
base.VisitNamespace(symbol);
}
public override object VisitNamespace(INamespaceSymbol symbol)
{
var members = symbol.GetMembers().Select(m => m.Accept(this)).ToList();
var namespaces = members.OfType <List <TypeInfo> >();
var types = members.OfType <TypeInfo>();
return(namespaces.SelectMany(n => n).Concat(types).ToList());
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
symbols.Add(symbol);
foreach (var childSymbol in symbol.GetMembers())
{
childSymbol.Accept(this);
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
foreach (var childSymbol in symbol.GetMembers())
{
//We must implement the visitor pattern ourselves and
//accept the child symbols in order to visit their children
childSymbol.Accept(this);
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
// TODO Use parallel foreach
foreach (var member in symbol.GetMembers())
{
member.Accept(this);
}
//Parallel.ForEach(symbol.GetMembers(), s => s.Accept(this));
}
internal static INamespaceSymbol GetNestedNamespace(this INamespaceSymbol container, string name)
{
foreach (INamespaceOrTypeSymbol sym in container.GetMembers(name))
{
if (sym.Kind == SymbolKind.Namespace)
{
return((INamespaceSymbol)sym);
}
}
return(null);
}
public override IEnumerable <INamedTypeSymbol> VisitNamespace(INamespaceSymbol symbol)
{
foreach (var childSymbol in symbol.GetMembers())
{
//We must implement the visitor pattern ourselves and
//accept the child symbols in order to visit their children
foreach (var result in childSymbol.Accept(this))
{
yield return(result);
}
}
}
public static INamespaceSymbol GetNestedNamespace(this INamespaceSymbol ns, string name)
{
foreach (var sym in ns.GetMembers(name))
{
if (sym.Kind == SymbolKind.Namespace)
{
return((INamespaceSymbol)sym);
}
}
return(null);
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
if (symbol.DeclaringSyntaxReferences.Length == 0)
{
return;
}
foreach (var namespaceOrTypeSymbol in symbol.GetMembers())
{
namespaceOrTypeSymbol.Accept(this);
}
}
/// <summary>
/// Prepares the <see cref="NamespaceMemberBuilder"/> from the <paramref name="symbol"/>
/// and adds it to <see cref="AssemblyMemberBuilder.Namespaces"/>
/// </summary>
/// <param name="symbol">Source <see cref="INamespaceSymbol"/></param>
/// <param name="root">Builder root</param>
/// <param name="assembly">Parent <see cref="AssemblyMemberBuilder"/></param>
/// <param name="level">Hierarchy level (used to indent the console output)</param>
private static void BuildNamespace(INamespaceSymbol symbol, RootMemberBuilder root, AssemblyMemberBuilder assembly, int level)
{
var children = symbol.GetMembers().ToArray();
var childNamespaces = children.OfType <INamespaceSymbol>().ToArray();
var childTypes = children.OfType <ITypeSymbol>().ToArray();
NamespaceMemberBuilder n = null;
if (childTypes.Length > 0) //check if not "empty" namespace resp. part of "dot syntax" (when there is a ns a.b.c.d and "d" is the only one containing the types, the a,b and c are in symbols hierarchy as "empty" ns
{
n = new NamespaceMemberBuilder()
{
Name = SymbolDisplay.ToDisplayString(symbol),
NameBase = SymbolDisplay.ToDisplayString(symbol),
Symbol = symbol,
DocumentationId = symbol.GetDocumentationCommentId(),
};
//ns documentation - internal class NamespaceDoc { }
var docClass = symbol.GetMembers("NamespaceDoc").OfType <INamedTypeSymbol>().FirstOrDefault();
if (docClass != null)
{
n.DocumentationXml = docClass.GetDocumentationCommentXml();
n.Documentation = Documentation.Read(n.DocumentationXml);
}
assembly.Namespaces.Add(n);
Console.WriteLine($"{new string(' ', level)} read as {n}");
foreach (var memberSymbol in childTypes)
{
Build(memberSymbol, root, assembly, n, null, level + 1);
}
}
foreach (var memberSymbol in childNamespaces)
{
Build(memberSymbol, root, assembly, n, null, level + 1);
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
if (IsUnimportantSymbol(symbol))
return;
PrettyPrint(symbol);
tabCount++;
foreach(var childSymbol in symbol.GetMembers())
{
childSymbol.Accept(this);
}
tabCount--;
}
public override void VisitNamespace([NotNull] INamespaceSymbol symbol)
{
if (!IsComplete)
{
foreach (INamespaceOrTypeSymbol member in symbol.GetMembers())
{
member.Accept(this);
if (IsComplete)
{
return;
}
}
}
}
public override MetadataItem VisitNamespace(INamespaceSymbol symbol)
{
var item = DefaultVisit(symbol);
if (item == null)
{
return(null);
}
item.Type = MemberType.Namespace;
item.Items = VisitDescendants(
symbol.GetMembers().OfType <ITypeSymbol>(),
t => t.GetMembers().OfType <ITypeSymbol>(),
t => true);
AddReference(symbol);
return(item);
}
public override Node VisitNamespace(INamespaceSymbol symbol)
{
var node = this._graph.AddNode(GetId(symbol));
node.LabelText = symbol.IsGlobalNamespace ? "(Global Namespace)" : symbol.Name;
node.Label.FontColor = Color.White;
node.Attr.FillColor = Color.DarkKhaki;
foreach (var member in symbol.GetMembers())
{
var child = this.Visit(member);
this._graph.AddEdge(node.Id, child.Id);
}
return(node);
}
private void AddNamespace(INamespaceSymbol namespaceSymbol)
{
if (!_names.IsEmpty) return;
var classList = namespaceSymbol.GetMembers();
var methodsList = classList.ToList().SelectMany(x => x.GetMembers());
var methods = new List<ISymbol>(methodsList);
try
{
_names = new ConcurrentBag<ISymbol>(methods);
}
catch
{
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
if (_finished || _symbolPredicate == null || _symbolPredicate(symbol))
{
AddDocument(symbol, true, new MetadataItems
{
{ CodeAnalysisKeys.SpecificKind, (k, m) => symbol.Kind.ToString() },
{ CodeAnalysisKeys.MemberNamespaces, DocumentsFor(symbol.GetNamespaceMembers()) },
{ CodeAnalysisKeys.MemberTypes, DocumentsFor(symbol.GetTypeMembers()) }
});
}
// Descend if not finished, regardless if this namespace was included
if (!_finished)
{
Parallel.ForEach(symbol.GetMembers(), s => s.Accept(this));
}
}
public override void VisitNamespace(INamespaceSymbol symbol)
{
foreach (var member in symbol.GetMembers()) { Visit(member); }
base.VisitNamespace(symbol);
}
private NestedUnitNamespace TranslateMetadata(INamespaceSymbol namespaceSymbol) {
Contract.Requires(namespaceSymbol != null);
Contract.Ensures(Contract.Result<UnitNamespace>() != null);
IUnitNamespaceReference nsr;
if (this.namespaceSymbolCache.TryGetValue(namespaceSymbol, out nsr)) {
var alreadyTranslatedNamespace = nsr as IUnitNamespace;
if (alreadyTranslatedNamespace != null) return alreadyTranslatedNamespace as NestedUnitNamespace;
}
var ns = CreateNamespaceDefinition(namespaceSymbol);
var mems = new List<INamespaceMember>();
foreach (var m in namespaceSymbol.GetMembers()) {
var nestedNamespaceSymbol = m as INamespaceSymbol;
if (nestedNamespaceSymbol != null) {
var cciNtd = TranslateMetadata(nestedNamespaceSymbol);
mems.Add(cciNtd);
}
var typeSymbol = m as INamedTypeSymbol;
if (typeSymbol != null) {
var cciType = (INamespaceTypeDefinition)TranslateMetadata(typeSymbol);
mems.Add(cciType);
continue;
}
}
ns.Members = mems;
return ns;
}
internal static void MapGlobalTypes(NamespaceInfoMap nsInfoMap, INamespaceSymbol nsSymbol)
{
if (!nsSymbol.IsGlobalNamespace)
{
foreach (var nsInfo in nsInfoMap.Values)
{
if (nsSymbol.FullNameEquals(nsInfo.DottedName.NameParts))
{
var typeSymbolList = nsSymbol.GetMembers().OfType<INamedTypeSymbol>().Where(i => i.TypeKind == Microsoft.CodeAnalysis.TypeKind.Class).ToList();
for (var i = 0; i < typeSymbolList.Count;)
{
var typeSymbol = typeSymbolList[i];
var clsAttData = typeSymbol.GetAttributeData(SchemaClassAttributeNameParts);
if (clsAttData != null)
{
if (typeSymbol.IsGenericType)
{
CompilerContext.ErrorAndThrow(new DiagMsgEx(DiagCodeEx.SchemaClassCannotBeGeneric), GetTextSpan(typeSymbol));
}
if (typeSymbol.IsStatic)
{
CompilerContext.ErrorAndThrow(new DiagMsgEx(DiagCodeEx.SchemaClassCannotBeStatic), GetTextSpan(typeSymbol));
}
var clsName = GetFirstArgumentAsString(clsAttData);
if (clsName == null)
{
CompilerContext.ErrorAndThrow(new DiagMsgEx(DiagCodeEx.InvalidSchemaClassAttribute), GetTextSpan(clsAttData));
}
var clsInfo = nsInfo.TryGetGlobalType<ClassTypeInfo>(clsName);
if (clsInfo == null)
{
CompilerContext.ErrorAndThrow(new DiagMsgEx(DiagCodeEx.InvalidSchemaClassAttributeName, clsName), GetTextSpan(clsAttData));
}
if (clsInfo.Symbol != null)
{
CompilerContext.ErrorAndThrow(new DiagMsgEx(DiagCodeEx.DuplicateSchemaClassAttributeName, clsName), GetTextSpan(clsAttData));
}
if (!clsInfo.IsAbstract)
{
if (typeSymbol.IsAbstract)
{
CompilerContext.ErrorAndThrow(new DiagMsgEx(DiagCodeEx.NonAbstractSchemaClassRequired),
GetTextSpan(typeSymbol));
}
if (!typeSymbol.HasParameterlessConstructor())
{
CompilerContext.ErrorAndThrow(new DiagMsgEx(DiagCodeEx.ParameterlessConstructorRequired),
GetTextSpan(typeSymbol));
}
}
clsInfo.Symbol = typeSymbol;
typeSymbolList.RemoveAt(i);
continue;
}
++i;
}
foreach (var typeSymbol in typeSymbolList)
{
if (!typeSymbol.IsGenericType)
{
var clsName = typeSymbol.Name;
var clsInfo = nsInfo.TryGetGlobalType<ClassTypeInfo>(clsName);
if (clsInfo != null)
{
if (clsInfo.Symbol == null)
{
if (typeSymbol.IsStatic)
{
CompilerContext.ErrorAndThrow(new DiagMsgEx(DiagCodeEx.SchemaClassCannotBeStatic), GetTextSpan(typeSymbol));
}
if (!clsInfo.IsAbstract)
{
if (typeSymbol.IsAbstract)
{
CompilerContext.ErrorAndThrow(new DiagMsgEx(DiagCodeEx.NonAbstractSchemaClassRequired),
GetTextSpan(typeSymbol));
}
if (!typeSymbol.HasParameterlessConstructor())
{
CompilerContext.ErrorAndThrow(new DiagMsgEx(DiagCodeEx.ParameterlessConstructorRequired),
GetTextSpan(typeSymbol));
}
}
clsInfo.Symbol = typeSymbol;
}
}
}
}
}
}
}
foreach (var subNsSymbol in nsSymbol.GetNamespaceMembers())
{
MapGlobalTypes(nsInfoMap, subNsSymbol);
}
}
private bool BindsWithoutErrors(INamespaceSymbol ns, string rightName, bool isAttributeName)
{
// If there was no name on the right, then this binds without any problems.
if (rightName == null)
{
return true;
}
// Otherwise, see if the namespace we will bind this contains a member with the same
// name as the name on the right.
var types = ns.GetMembers(rightName);
if (types.Any())
{
return true;
}
if (!isAttributeName)
{
return false;
}
return BindsWithoutErrors(ns, rightName + "Attribute", isAttributeName: false);
}
private ImmutableArray<INamedTypeSymbol> GetRuleDependencyAttributeTypeSymbols(INamespaceSymbol globalNamespace)
{
var builder = ImmutableArray.CreateBuilder<INamedTypeSymbol>();
foreach (var antlr4Namespace in globalNamespace.GetMembers("Antlr4").OfType<INamespaceSymbol>())
{
foreach (var runtimeNamespace in antlr4Namespace.GetMembers("Runtime").OfType<INamespaceSymbol>())
{
builder.AddRange(runtimeNamespace.GetTypeMembers("RuleDependencyAttribute"));
}
}
return builder.ToImmutable();
}
