public override SingleNamespaceOrTypeDeclaration VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
var children = VisitNamespaceChildren(node, node.Members, node.Green.Members);
bool hasUsings = node.Usings.Any();
bool hasExterns = node.Externs.Any();
NameSyntax name = node.Name;
CSharpSyntaxNode currentNode = node;
QualifiedNameSyntax dotted;
while ((dotted = name as QualifiedNameSyntax) != null)
{
var ns = SingleNamespaceDeclaration.Create(
name: dotted.Right.Identifier.ValueText,
hasUsings: hasUsings,
hasExternAliases: hasExterns,
syntaxReference: _syntaxTree.GetReference(currentNode),
nameLocation: new SourceLocation(dotted.Right),
children: children,
diagnostics: ImmutableArray <Diagnostic> .Empty);
var nsDeclaration = new[] { ns };
children = nsDeclaration.AsImmutableOrNull <SingleNamespaceOrTypeDeclaration>();
currentNode = name = dotted.Left;
hasUsings = false;
hasExterns = false;
}
var diagnostics = DiagnosticBag.GetInstance();
if (ContainsGeneric(node.Name))
{
// We're not allowed to have generics.
diagnostics.Add(ErrorCode.ERR_UnexpectedGenericName, node.Name.GetLocation());
}
if (ContainsAlias(node.Name))
{
diagnostics.Add(ErrorCode.ERR_UnexpectedAliasedName, node.Name.GetLocation());
}
// NOTE: *Something* has to happen for alias-qualified names. It turns out that we
// just grab the part after the colons (via GetUnqualifiedName, below). This logic
// must be kept in sync with NamespaceSymbol.GetNestedNamespace.
return(SingleNamespaceDeclaration.Create(
name: name.GetUnqualifiedName().Identifier.ValueText,
hasUsings: hasUsings,
hasExternAliases: hasExterns,
syntaxReference: _syntaxTree.GetReference(currentNode),
nameLocation: new SourceLocation(name),
children: children,
diagnostics: diagnostics.ToReadOnlyAndFree()));
}
public override SingleNamespaceOrTypeDeclaration VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
var children = VisitNamespaceChildren(node, node.Members, node.Green.Members);
if (syntaxTree.Options.Kind == SourceCodeKind.Interactive || syntaxTree.Options.Kind == SourceCodeKind.Script)
{
referenceDirectiveDiagnostics = referenceDirectiveDiagnostics ?? new List <Diagnostic>();
referenceDirectiveDiagnostics.Add(new CSDiagnostic(
new DiagnosticInfo(MessageProvider.Instance, (int)ErrorCode.ERR_NamespaceNotAllowedInScript),
new SourceLocation(node.NamespaceKeyword)));
}
bool hasUsings = node.Usings.Any();
bool hasExterns = node.Externs.Any();
NameSyntax name = node.Name;
CSharpSyntaxNode currentNode = node;
while (name is QualifiedNameSyntax)
{
var dotted = name as QualifiedNameSyntax;
var ns = SingleNamespaceDeclaration.Create(
name: dotted.Right.Identifier.ValueText,
hasUsings: hasUsings,
hasExternAliases: hasExterns,
syntaxReference: syntaxTree.GetReference(currentNode),
nameLocation: new SourceLocation(dotted.Right),
children: children);
var nsDeclaration = new[] { ns };
children = nsDeclaration.AsImmutableOrNull <SingleNamespaceOrTypeDeclaration>();
currentNode = name = dotted.Left;
hasUsings = false;
hasExterns = false;
}
// NOTE: *Something* has to happen for alias-qualified names. It turns out that we
// just grab the part after the colons (via GetUnqualifiedName, below). This logic
// must be kept in sync with NamespaceSymbol.GetNestedNamespace.
return(SingleNamespaceDeclaration.Create(
name: name.GetUnqualifiedName().Identifier.ValueText,
hasUsings: hasUsings,
hasExternAliases: hasExterns,
syntaxReference: syntaxTree.GetReference(currentNode),
nameLocation: new SourceLocation(name),
children: children));
}
private SingleNamespaceOrTypeDeclaration CreateScriptClass(
CompilationUnitSyntax parent,
ImmutableArray <SingleTypeDeclaration> children,
ImmutableHashSet <string> memberNames,
SingleTypeDeclaration.TypeDeclarationFlags declFlags
)
{
Debug.Assert(
parent.Kind() == SyntaxKind.CompilationUnit &&
_syntaxTree.Options.Kind != SourceCodeKind.Regular
);
// script type is represented by the parent node:
var parentReference = _syntaxTree.GetReference(parent);
var fullName = _scriptClassName.Split('.');
// Note: The symbol representing the merged declarations uses parentReference to enumerate non-type members.
SingleNamespaceOrTypeDeclaration decl = new SingleTypeDeclaration(
kind: _isSubmission ? DeclarationKind.Submission : DeclarationKind.Script,
name: fullName.Last(),
arity: 0,
modifiers: DeclarationModifiers.Internal
| DeclarationModifiers.Partial
| DeclarationModifiers.Sealed,
declFlags: declFlags,
syntaxReference: parentReference,
nameLocation: new SourceLocation(parentReference),
memberNames: memberNames,
children: children,
diagnostics: ImmutableArray <Diagnostic> .Empty
);
for (int i = fullName.Length - 2; i >= 0; i--)
{
decl = SingleNamespaceDeclaration.Create(
name: fullName[i],
hasUsings: false,
hasExternAliases: false,
syntaxReference: parentReference,
nameLocation: new SourceLocation(parentReference),
children: ImmutableArray.Create(decl),
diagnostics: ImmutableArray <Diagnostic> .Empty
);
}
return(decl);
}
public override SingleNamespaceOrTypeDeclaration VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
var children = VisitNamespaceChildren(node, node.Members, node.Green.Members);
bool hasUsings = node.Usings.Any();
bool hasExterns = node.Externs.Any();
NameSyntax name = node.Name;
CSharpSyntaxNode currentNode = node;
while (name is QualifiedNameSyntax)
{
var dotted = name as QualifiedNameSyntax;
var ns = SingleNamespaceDeclaration.Create(
name: dotted.Right.Identifier.ValueText,
hasUsings: hasUsings,
hasExternAliases: hasExterns,
syntaxReference: _syntaxTree.GetReference(currentNode),
nameLocation: new SourceLocation(dotted.Right),
children: children);
var nsDeclaration = new[] { ns };
children = nsDeclaration.AsImmutableOrNull <SingleNamespaceOrTypeDeclaration>();
currentNode = name = dotted.Left;
hasUsings = false;
hasExterns = false;
}
// NOTE: *Something* has to happen for alias-qualified names. It turns out that we
// just grab the part after the colons (via GetUnqualifiedName, below). This logic
// must be kept in sync with NamespaceSymbol.GetNestedNamespace.
return(SingleNamespaceDeclaration.Create(
name: name.GetUnqualifiedName().Identifier.ValueText,
hasUsings: hasUsings,
hasExternAliases: hasExterns,
syntaxReference: _syntaxTree.GetReference(currentNode),
nameLocation: new SourceLocation(name),
children: children));
}
/// <summary>
/// Returns imported symbols for the given declaration.
/// </summary>
internal Imports GetImports(SingleNamespaceDeclaration declaration)
{
return GetBinderFactory(declaration.SyntaxReference.SyntaxTree).GetImportsBinder((CSharpSyntaxNode)declaration.SyntaxReference.GetSyntax()).GetImports();
}
private SingleNamespaceDeclaration VisitBaseNamespaceDeclaration(BaseNamespaceDeclarationSyntax node)
{
var children = VisitNamespaceChildren(node, node.Members, ((Syntax.InternalSyntax.BaseNamespaceDeclarationSyntax)node.Green).Members);
bool hasUsings = node.Usings.Any();
bool hasExterns = node.Externs.Any();
NameSyntax name = node.Name;
CSharpSyntaxNode currentNode = node;
QualifiedNameSyntax dotted;
while ((dotted = name as QualifiedNameSyntax) != null)
{
var ns = SingleNamespaceDeclaration.Create(
name: dotted.Right.Identifier.ValueText,
hasUsings: hasUsings,
hasExternAliases: hasExterns,
syntaxReference: _syntaxTree.GetReference(currentNode),
nameLocation: new SourceLocation(dotted.Right),
children: children,
diagnostics: ImmutableArray <Diagnostic> .Empty);
var nsDeclaration = new[] { ns };
children = nsDeclaration.AsImmutableOrNull <SingleNamespaceOrTypeDeclaration>();
currentNode = name = dotted.Left;
hasUsings = false;
hasExterns = false;
}
var diagnostics = DiagnosticBag.GetInstance();
if (node is FileScopedNamespaceDeclarationSyntax)
{
if (node.Parent is FileScopedNamespaceDeclarationSyntax)
{
// Happens when user writes:
// namespace A.B;
// namespace X.Y;
diagnostics.Add(ErrorCode.ERR_MultipleFileScopedNamespace, node.Name.GetLocation());
}
else if (node.Parent is NamespaceDeclarationSyntax)
{
// Happens with:
//
// namespace A.B
// {
// namespace X.Y;
diagnostics.Add(ErrorCode.ERR_FileScopedAndNormalNamespace, node.Name.GetLocation());
}
else
{
// Happens with cases like:
//
// namespace A.B { }
// namespace X.Y;
//
// or even
//
// class C { }
// namespace X.Y;
Debug.Assert(node.Parent is CompilationUnitSyntax);
var compilationUnit = (CompilationUnitSyntax)node.Parent;
if (node != compilationUnit.Members[0])
{
diagnostics.Add(ErrorCode.ERR_FileScopedNamespaceNotBeforeAllMembers, node.Name.GetLocation());
}
}
}
else
{
Debug.Assert(node is NamespaceDeclarationSyntax);
// namespace X.Y;
// namespace A.B { }
if (node.Parent is FileScopedNamespaceDeclarationSyntax)
{
diagnostics.Add(ErrorCode.ERR_FileScopedAndNormalNamespace, node.Name.GetLocation());
}
}
if (ContainsGeneric(node.Name))
{
// We're not allowed to have generics.
diagnostics.Add(ErrorCode.ERR_UnexpectedGenericName, node.Name.GetLocation());
}
if (ContainsAlias(node.Name))
{
diagnostics.Add(ErrorCode.ERR_UnexpectedAliasedName, node.Name.GetLocation());
}
if (node.AttributeLists.Count > 0)
{
diagnostics.Add(ErrorCode.ERR_BadModifiersOnNamespace, node.AttributeLists[0].GetLocation());
}
if (node.Modifiers.Count > 0)
{
diagnostics.Add(ErrorCode.ERR_BadModifiersOnNamespace, node.Modifiers[0].GetLocation());
}
foreach (var directive in node.Usings)
{
if (directive.GlobalKeyword.IsKind(SyntaxKind.GlobalKeyword))
{
diagnostics.Add(ErrorCode.ERR_GlobalUsingInNamespace, directive.GlobalKeyword.GetLocation());
break;
}
}
// NOTE: *Something* has to happen for alias-qualified names. It turns out that we
// just grab the part after the colons (via GetUnqualifiedName, below). This logic
// must be kept in sync with NamespaceSymbol.GetNestedNamespace.
return(SingleNamespaceDeclaration.Create(
name: name.GetUnqualifiedName().Identifier.ValueText,
hasUsings: hasUsings,
hasExternAliases: hasExterns,
syntaxReference: _syntaxTree.GetReference(currentNode),
nameLocation: new SourceLocation(name),
children: children,
diagnostics: diagnostics.ToReadOnlyAndFree()));
}
public static MergedNamespaceDeclaration Create(
MergedNamespaceDeclaration mergedDeclaration,
SingleNamespaceDeclaration declaration)
{
return(new MergedNamespaceDeclaration(mergedDeclaration.declarations.Add(declaration)));
}
public static MergedNamespaceDeclaration Create(SingleNamespaceDeclaration declaration)
{
return(new MergedNamespaceDeclaration(ImmutableArray.Create(declaration)));
}
public static MergedNamespaceDeclaration Create(
MergedNamespaceDeclaration mergedDeclaration,
SingleNamespaceDeclaration declaration)
{
return new MergedNamespaceDeclaration(mergedDeclaration._declarations.Add(declaration));
}
public static MergedNamespaceDeclaration Create(SingleNamespaceDeclaration declaration)
{
return new MergedNamespaceDeclaration(ImmutableArray.Create(declaration));
}