public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
// This information is not yet extracted.
cx.Extractor.Message(new Message {
severity = Severity.Info, message = "Ignoring extern alias directive"
});
}
public AliasAndExternAliasDirective(
AliasSymbol alias,
ExternAliasDirectiveSyntax externAliasDirective
)
{
this.Alias = alias;
this.ExternAliasDirective = externAliasDirective;
}
public static Doc Print(ExternAliasDirectiveSyntax node)
{
return(Doc.Concat(
ExtraNewLines.Print(node),
Token.PrintWithSuffix(node.ExternKeyword, " "),
Token.PrintWithSuffix(node.AliasKeyword, " "),
Token.Print(node.Identifier),
Token.Print(node.SemicolonToken)
));
}
private Doc PrintExternAliasDirectiveSyntax(
ExternAliasDirectiveSyntax node)
{
return(Concat(
this.PrintExtraNewLines(node),
this.PrintSyntaxToken(node.ExternKeyword, " "),
this.PrintSyntaxToken(node.AliasKeyword, " "),
this.PrintSyntaxToken(node.Identifier),
this.PrintSyntaxToken(node.SemicolonToken)
));
}
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
if (!PreVisit(node))
{
return;
}
base.VisitExternAliasDirective(node);
PostVisit(node);
}
protected override bool IsFinalSemicolonOfUsingOrExtern(SyntaxNode directive, SyntaxToken token)
{
if (token.IsKind(SyntaxKind.None) || token.IsMissing)
{
return(false);
}
return(directive switch
{
UsingDirectiveSyntax usingDirective => usingDirective.SemicolonToken == token,
ExternAliasDirectiveSyntax externAliasDirective => externAliasDirective.SemicolonToken == token,
_ => false,
});
private static void AnalyzeCompilationUnit(SyntaxNodeAnalysisContext context)
{
var compilationUnit = (CompilationUnitSyntax)context.Node;
UsingDirectiveSyntax usingDirective = compilationUnit.Usings.FirstOrDefault();
if (usingDirective == null)
{
return;
}
SyntaxTriviaList.Reversed.Enumerator en = usingDirective.GetLeadingTrivia().Reverse().GetEnumerator();
if (en.MoveNext())
{
if (en.Current.IsWhitespaceTrivia() &&
!en.MoveNext())
{
if (IsPrecededWithExternAliasDirective())
{
ReportDiagnostic(usingDirective.SpanStart);
}
}
else if (en.Current.IsEndOfLineTrivia() &&
en.MoveNext() &&
en.Current.IsKind(SyntaxKind.SingleLineCommentTrivia))
{
ReportDiagnostic(usingDirective.SpanStart);
}
}
else if (IsPrecededWithExternAliasDirective())
{
ReportDiagnostic(usingDirective.SpanStart);
}
bool IsPrecededWithExternAliasDirective()
{
ExternAliasDirectiveSyntax externAliasDirective = compilationUnit.Externs.LastOrDefault();
return(externAliasDirective?.FullSpan.End == usingDirective.FullSpan.Start &&
SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(externAliasDirective.GetTrailingTrivia()));
}
void ReportDiagnostic(int position)
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.AddEmptyLineBeforeUsingDirectiveList,
Location.Create(compilationUnit.SyntaxTree, new TextSpan(position, 0)));
}
}
private void AddExterns(
ref CompilationUnitSyntax root,
ref NamespaceDeclarationSyntax namespaceToUpdate,
ExternAliasDirectiveSyntax externAliasDirective)
{
if (namespaceToUpdate != null)
{
namespaceToUpdate = namespaceToUpdate.AddExterns(externAliasDirective);
}
else
{
root = root.AddExterns(externAliasDirective);
}
}
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
// if (debug) Console.WriteLine(node.ToFullString());
// if (debug) Console.WriteLine(node.ToString());
// Todo("ExternAliasDirective");
// var nl = OurLine.NewLine(LineKind.Decl, "ExternAliasDirective");
// nl.Source = node.ToFullString();
// nl.ParentKind = node.Parent.RawKind;
// nl.RawKind = node.RawKind;
// LogCommand(nl);
base.VisitExternAliasDirective(node);
}
private static UsingKind GetUsingKind(UsingDirectiveSyntax usingDirective, ExternAliasDirectiveSyntax externDirective)
{
if (externDirective != null)
{
return(UsingKind.Extern);
}
if (usingDirective.Alias != null)
{
return(UsingKind.Alias);
}
if (usingDirective.StaticKeyword != default)
{
return(UsingKind.UsingStatic);
}
return(UsingKind.Namespace);
}
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
CheckForInvalid(node);
base.VisitExternAliasDirective(node);
}
internal AliasSymbol(InContainerBinder binder, ExternAliasDirectiveSyntax syntax)
: this(binder, syntax.Identifier)
{
this.isExtern = true;
}
public void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
WriteLeadingTrivia(node);
_writer.WriteIndent();
_writer.WriteKeyword(PrinterKeyword.Extern);
_writer.WriteSpace();
_writer.WriteKeyword(PrinterKeyword.Alias);
_writer.WriteSpace();
_writer.WriteIdentifier(node.Identifier);
_writer.EndStatement();
WriteTrailingTrivia(node);
}
public IAliasSymbol?ToSymbol(ExternAliasDirectiveSyntax node) => Model.GetDeclaredSymbol(node, CancellationToken);
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
CheckForInvalid(node);
base.VisitExternAliasDirective(node);
}
public override SyntaxNode VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
node = (ExternAliasDirectiveSyntax)base.VisitExternAliasDirective(node);
Classes.Add(node);
return(node);
}
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
InsertLLOCMap(node.GetLocation());
base.VisitExternAliasDirective(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitExternAliasDirective(node);
}
public RichGenerationContext AddExtern(ExternAliasDirectiveSyntax externAliasDirective)
{
Externs.Add(externAliasDirective);
return(this);
}
/// <summary>
/// Given an extern alias declaration get the corresponding symbol for the alias that was introduced.
/// </summary>
/// <param name="declarationSyntax"></param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The alias symbol that was declared, or null if a duplicate alias symbol was declared.</returns>
public override IAliasSymbol GetDeclaredSymbol(ExternAliasDirectiveSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
using (Logger.LogBlock(FunctionId.CSharp_SemanticModel_GetDeclaredSymbol, message: this.SyntaxTree.FilePath, cancellationToken: cancellationToken))
{
CheckSyntaxNode(declarationSyntax);
var binder = _binderFactory.GetImportsBinder(declarationSyntax.Parent);
var imports = binder.GetImports();
// TODO: If this becomes a bottleneck, put the extern aliases in a dictionary, as for using aliases.
foreach (var alias in imports.ExternAliases)
{
if (alias.Alias.Locations[0].SourceSpan == declarationSyntax.Identifier.Span)
{
return alias.Alias;
}
}
return new AliasSymbol(binder, declarationSyntax);
}
}
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
// This information is not yet extracted.
cx.ExtractionError("Not implemented extern alias directive", node.ToFullString(), Extraction.Entities.Location.Create(cx, node.GetLocation()), "", Severity.Info);
}
public AliasAndExternAliasDirective(AliasSymbol alias, ExternAliasDirectiveSyntax externAliasDirective)
{
this.Alias = alias;
this.ExternAliasDirective = externAliasDirective;
}
/// <summary> /// Given an extern alias declaration get the corresponding symbol for the alias that was introduced. /// </summary> /// <param name="declarationSyntax"></param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The alias symbol that was declared, or null if a duplicate alias symbol was declared.</returns> public abstract IAliasSymbol GetDeclaredSymbol(ExternAliasDirectiveSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken));
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
throw new NotImplementedException();
}
public override IAliasSymbol GetDeclaredSymbol(ExternAliasDirectiveSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
// Can't define an extern alias inside a member.
return null;
}
internal AliasSymbol(Binder binder, ExternAliasDirectiveSyntax syntax)
: this(binder, syntax.Identifier)
{
_isExtern = true;
}
public TooltipInformation GetExternAliasTooltip (ExternAliasDirectiveSyntax externAliasDeclaration, DotNetProject project)
{
var result = new TooltipInformation ();
result.SignatureMarkup = Highlight ("extern ", colorStyle.KeywordModifiers) + Highlight ("alias ", colorStyle.KeywordNamespace) + externAliasDeclaration.Identifier;
if (project == null)
return result;
foreach (var r in project.References) {
if (string.IsNullOrEmpty (r.Aliases))
continue;
foreach (var alias in r.Aliases.Split (',', ';')) {
if (alias == externAliasDeclaration.Identifier.ToFullString ())
result.AddCategory (GettextCatalog.GetString ("Reference"), r.StoredReference);
}
}
return result;
}
/// <summary>
/// Given an extern alias declaration get the corresponding symbol for the alias that was introduced.
/// </summary>
/// <param name="declarationSyntax"></param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The alias symbol that was declared, or null if a duplicate alias symbol was declared.</returns>
public override IAliasSymbol GetDeclaredSymbol(ExternAliasDirectiveSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
CheckSyntaxNode(declarationSyntax);
var binder = _binderFactory.GetImportsBinder(declarationSyntax.Parent);
var imports = binder.GetImports(basesBeingResolved: null);
// TODO: If this becomes a bottleneck, put the extern aliases in a dictionary, as for using aliases.
foreach (var alias in imports.ExternAliases)
{
if (alias.Alias.Locations[0].SourceSpan == declarationSyntax.Identifier.Span)
{
return alias.Alias;
}
}
return new AliasSymbol(binder, declarationSyntax);
}
//public override void VisitExpressionStatement(ExpressionStatementSyntax node)
//{
// base.VisitExpressionStatement(node);
//}
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
Debug.Fail(node.ToString());
base.VisitExternAliasDirective(node);
}
public override Evaluation VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
return(base.VisitExternAliasDirective(node));
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitExternAliasDirective(node);
}
public override UstNode VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
return(null);
}
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
base.VisitExternAliasDirective(node);
Colorize(node.AliasKeyword.Span, externAliasKeywordColor);
}
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
LogicalLineCount++;
base.VisitExternAliasDirective(node);
}
public override void VisitExternAliasDirective(ExternAliasDirectiveSyntax node)
{
base.VisitExternAliasDirective(node);
}
// // Summary: // Called when the visitor visits a ExternAliasDirectiveSyntax node. public virtual void VisitExternAliasDirective(ExternAliasDirectiveSyntax node);
internal void RecordImport(ExternAliasDirectiveSyntax syntax)
{
RecordImportInternal(syntax);
}
public TameExternAliasDirectiveSyntax(ExternAliasDirectiveSyntax node)
{
Node = node;
AddChildren();
}
