private static string[] GetNonTypeMemberNames(Syntax.InternalSyntax.SyntaxList <Syntax.InternalSyntax.MemberDeclarationSyntax> members, ref SingleTypeDeclaration.TypeDeclarationFlags declFlags)
{
bool anyMethodHadExtensionSyntax = false;
bool anyMemberHasAttributes = false;
bool anyNonTypeMembers = false;
var set = PooledHashSet <string> .GetInstance();
foreach (var member in members)
{
AddNonTypeMemberNames(member, set, ref anyNonTypeMembers);
// Check to see if any method contains a 'this' modifier on its first parameter.
// This data is used to determine if a type needs to have its members materialized
// as part of extension method lookup.
if (!anyMethodHadExtensionSyntax && CheckMethodMemberForExtensionSyntax(member))
{
anyMethodHadExtensionSyntax = true;
}
if (!anyMemberHasAttributes && CheckMemberForAttributes(member))
{
anyMemberHasAttributes = true;
}
}
if (anyMethodHadExtensionSyntax)
{
declFlags |= SingleTypeDeclaration.TypeDeclarationFlags.AnyMemberHasExtensionMethodSyntax;
}
if (anyMemberHasAttributes)
{
declFlags |= SingleTypeDeclaration.TypeDeclarationFlags.AnyMemberHasAttributes;
}
if (anyNonTypeMembers)
{
declFlags |= SingleTypeDeclaration.TypeDeclarationFlags.HasAnyNontypeMembers;
}
// PERF: The member names collection tends to be long-lived. Use a string array since
// that uses less memory than a HashSet<string>.
string[] result;
if (set.Count == 0)
{
result = SpecializedCollections.EmptyArray <string>();
}
else
{
result = new string[set.Count];
set.CopyTo(result);
}
set.Free();
return(result);
}
private ImmutableArray <SingleNamespaceOrTypeDeclaration> VisitNamespaceChildren(
CSharpSyntaxNode node,
SyntaxList <MemberDeclarationSyntax> members,
Syntax.InternalSyntax.SyntaxList <Syntax.InternalSyntax.MemberDeclarationSyntax> internalMembers)
{
Debug.Assert(node.Kind == SyntaxKind.NamespaceDeclaration || (node.Kind == SyntaxKind.CompilationUnit && syntaxTree.Options.Kind == SourceCodeKind.Regular));
if (members.Count == 0)
{
return(ImmutableArray <SingleNamespaceOrTypeDeclaration> .Empty);
}
// We look for members that are not allowed in a namespace.
// If there are any we create an implicit class to wrap them.
bool hasGlobalMembers = false;
var childrenBuilder = ArrayBuilder <SingleNamespaceOrTypeDeclaration> .GetInstance();
foreach (var member in members)
{
SingleNamespaceOrTypeDeclaration namespaceOrType = Visit(member);
if (namespaceOrType != null)
{
childrenBuilder.Add(namespaceOrType);
}
else
{
hasGlobalMembers = hasGlobalMembers || member.Kind != SyntaxKind.IncompleteMember;
}
}
// wrap all members that are defined in a namespace or compilation unit into an implicit type:
if (hasGlobalMembers)
{
//The implicit class is not static and has no extensions
SingleTypeDeclaration.TypeDeclarationFlags declFlags = SingleTypeDeclaration.TypeDeclarationFlags.None;
var memberNames = GetNonTypeMemberNames(internalMembers, false, ref declFlags);
var container = syntaxTree.GetReference(node);
childrenBuilder.Add(CreateImplicitClass(memberNames, container, declFlags));
}
return(childrenBuilder.ToImmutableAndFree());
}
public static SeparatedSyntaxList <TNode> SeparatedList <TNode>(TNode node1, SyntaxToken token, TNode node2) where TNode : CSharpSyntaxNode
{
return(new SeparatedSyntaxList <TNode>(new SyntaxList <CSharpSyntaxNode>(SyntaxList.List(node1, token, node2))));
}
internal static CSharpSyntaxNode ListNode(params ArrayElement <CSharpSyntaxNode>[] nodes)
{
return(SyntaxList.List(nodes));
}
internal static CSharpSyntaxNode ListNode(CSharpSyntaxNode node0, CSharpSyntaxNode node1, CSharpSyntaxNode node2)
{
return(SyntaxList.List(node0, node1, node2));
}
public static SyntaxList <TNode> List <TNode>(TNode node0, TNode node1, TNode node2) where TNode : CSharpSyntaxNode
{
return(new SyntaxList <TNode>(SyntaxList.List(node0, node1, node2)));
}