public static IEnumerable<ReferencedSymbol> FilterToAliasMatches(
this IEnumerable<ReferencedSymbol> result,
IAliasSymbol aliasSymbolOpt)
{
if (aliasSymbolOpt == null)
{
return result;
}
return from r in result
let aliasLocations = r.Locations.Where(loc => SymbolEquivalenceComparer.Instance.Equals(loc.Alias, aliasSymbolOpt))
where aliasLocations.Any()
select new ReferencedSymbol(r.Definition, aliasLocations);
}
public static bool TryGetAliasSymbol(SemanticModel semanticModel, int namespaceId, INamespaceOrTypeSymbol targetSymbol, out IAliasSymbol aliasSymbol)
{
// TODO: given semantic model must be not speculative semantic model for now.
// currently it can't be checked since it is not exposed to common layer yet.
// once exposed, this method itself will make sure it use original semantic model
aliasSymbol = null;
if (!s_treeAliasMap.TryGetValue(semanticModel.Compilation, out var treeMap) ||
!treeMap.TryGetValue((semanticModel.SyntaxTree, namespaceId), out var symbolMap))
{
return false;
}
symbolMap.TryGetValue(targetSymbol, out aliasSymbol);
return true;
}
// We must verify that the alias actually binds back to the thing it's aliasing.
// It's possible there's another symbol with the same name as the alias that binds
// first
private static bool ValidateAliasForTarget(IAliasSymbol aliasReplacement, SemanticModel semanticModel, ExpressionSyntax node, ISymbol symbol)
{
var aliasName = aliasReplacement.Name;
var boundSymbols = semanticModel.LookupNamespacesAndTypes(node.SpanStart, name: aliasName);
if (boundSymbols.Length == 1)
{
var boundAlias = boundSymbols[0] as IAliasSymbol;
if (boundAlias != null && aliasReplacement.Target.Equals(symbol))
{
return true;
}
}
return false;
}
private static bool TryReplaceWithAlias(this ExpressionSyntax node, SemanticModel semanticModel, bool preferAliasToQualifiedName, CancellationToken cancellationToken, out IAliasSymbol aliasReplacement)
{
aliasReplacement = null;
if (!node.IsAliasReplaceableExpression())
{
return false;
}
var symbol = semanticModel.GetSymbolInfo(node, cancellationToken).Symbol;
// If the Symbol is a constructor get its containing type
if (symbol.IsConstructor())
{
symbol = symbol.ContainingType;
}
if (node is QualifiedNameSyntax || node is AliasQualifiedNameSyntax)
{
SyntaxAnnotation aliasAnnotationInfo = null;
// The following condition checks if the user has used alias in the original code and
// if so the expression is replaced with the Alias
if (node is QualifiedNameSyntax)
{
var qualifiedNameNode = (QualifiedNameSyntax)node;
if (qualifiedNameNode.Right.Identifier.HasAnnotations(AliasAnnotation.Kind))
{
aliasAnnotationInfo = qualifiedNameNode.Right.Identifier.GetAnnotations(AliasAnnotation.Kind).Single();
}
}
if (node is AliasQualifiedNameSyntax)
{
var aliasQualifiedNameNode = (AliasQualifiedNameSyntax)node;
if (aliasQualifiedNameNode.Name.Identifier.HasAnnotations(AliasAnnotation.Kind))
{
aliasAnnotationInfo = aliasQualifiedNameNode.Name.Identifier.GetAnnotations(AliasAnnotation.Kind).Single();
}
}
if (aliasAnnotationInfo != null)
{
var aliasName = AliasAnnotation.GetAliasName(aliasAnnotationInfo);
var aliasIdentifier = SyntaxFactory.IdentifierName(aliasName);
var aliasTypeInfo = semanticModel.GetSpeculativeAliasInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsTypeOrNamespace);
if (aliasTypeInfo != null)
{
aliasReplacement = aliasTypeInfo;
return ValidateAliasForTarget(aliasReplacement, semanticModel, node, symbol);
}
}
}
if (node.Kind() == SyntaxKind.IdentifierName &&
semanticModel.GetAliasInfo((IdentifierNameSyntax)node, cancellationToken) != null)
{
return false;
}
// an alias can only replace a type or namespace
if (symbol == null ||
(symbol.Kind != SymbolKind.Namespace && symbol.Kind != SymbolKind.NamedType))
{
return false;
}
if (node is QualifiedNameSyntax)
{
var qualifiedName = (QualifiedNameSyntax)node;
if (!qualifiedName.Right.HasAnnotation(Simplifier.SpecialTypeAnnotation))
{
var type = semanticModel.GetTypeInfo(node, cancellationToken).Type;
if (type != null)
{
var keywordKind = GetPredefinedKeywordKind(type.SpecialType);
if (keywordKind != SyntaxKind.None)
{
preferAliasToQualifiedName = false;
}
}
}
}
if (node is AliasQualifiedNameSyntax)
{
var aliasQualifiedNameSyntax = (AliasQualifiedNameSyntax)node;
if (!aliasQualifiedNameSyntax.Name.HasAnnotation(Simplifier.SpecialTypeAnnotation))
{
var type = semanticModel.GetTypeInfo(node, cancellationToken).Type;
if (type != null)
{
var keywordKind = GetPredefinedKeywordKind(type.SpecialType);
if (keywordKind != SyntaxKind.None)
{
preferAliasToQualifiedName = false;
}
}
}
}
aliasReplacement = GetAliasForSymbol((INamespaceOrTypeSymbol)symbol, node.GetFirstToken(), semanticModel, cancellationToken);
if (aliasReplacement != null && preferAliasToQualifiedName)
{
return ValidateAliasForTarget(aliasReplacement, semanticModel, node, symbol);
}
return false;
}
public RenameRewriter(RenameRewriterParameters parameters)
: base(visitIntoStructuredTrivia: true)
{
_documentId = parameters.Document.Id;
_renameRenamableSymbolDeclaration = parameters.RenamedSymbolDeclarationAnnotation;
_solution = parameters.OriginalSolution;
_replacementText = parameters.ReplacementText;
_originalText = parameters.OriginalText;
_possibleNameConflicts = parameters.PossibleNameConflicts;
_renameLocations = parameters.RenameLocations;
_conflictLocations = parameters.ConflictLocationSpans;
_cancellationToken = parameters.CancellationToken;
_semanticModel = parameters.SemanticModel;
_renamedSymbol = parameters.RenameSymbol;
_replacementTextValid = parameters.ReplacementTextValid;
_renameSpansTracker = parameters.RenameSpansTracker;
_isRenamingInStrings = parameters.OptionSet.GetOption(RenameOptions.RenameInStrings);
_isRenamingInComments = parameters.OptionSet.GetOption(RenameOptions.RenameInComments);
_stringAndCommentTextSpans = parameters.StringAndCommentTextSpans;
_renameAnnotations = parameters.RenameAnnotations;
_aliasSymbol = _renamedSymbol as IAliasSymbol;
_renamableDeclarationLocation = _renamedSymbol.Locations.FirstOrDefault(loc => loc.IsInSource && loc.SourceTree == _semanticModel.SyntaxTree);
_isVerbatim = _replacementText.StartsWith("@", StringComparison.Ordinal);
_simplificationService = parameters.Document.Project.LanguageServices.GetService<ISimplificationService>();
_semanticFactsService = parameters.Document.Project.LanguageServices.GetService<ISemanticFactsService>();
}
public static SerializableSymbolAndProjectId Dehydrate(
IAliasSymbol alias, Document document)
{
return alias == null
? null
: Dehydrate(new SymbolAndProjectId(alias, document.Project.Id));
}
public RenameRewriter(RenameRewriterParameters parameters)
: base(visitIntoStructuredTrivia: true)
{
this.documentId = parameters.Document.Id;
this.renameRenamableSymbolDeclaration = parameters.RenamedSymbolDeclarationAnnotation;
this.solution = parameters.OriginalSolution;
this.replacementText = parameters.ReplacementText;
this.originalText = parameters.OriginalText;
this.possibleNameConflicts = parameters.PossibleNameConflicts;
this.renameLocations = parameters.RenameLocations;
this.conflictLocations = parameters.ConflictLocationSpans;
this.cancellationToken = parameters.CancellationToken;
this.semanticModel = (SemanticModel)parameters.SemanticModel;
this.renamedSymbol = parameters.RenameSymbol;
this.replacementTextValid = parameters.ReplacementTextValid;
this.renameSpansTracker = parameters.RenameSpansTracker;
this.isRenamingInStrings = parameters.OptionSet.GetOption(RenameOptions.RenameInStrings);
this.isRenamingInComments = parameters.OptionSet.GetOption(RenameOptions.RenameInComments);
this.stringAndCommentTextSpans = parameters.StringAndCommentTextSpans;
this.renameAnnotations = parameters.RenameAnnotations;
this.aliasSymbol = this.renamedSymbol as IAliasSymbol;
this.renamableDeclarationLocation = this.renamedSymbol.Locations.Where(loc => loc.IsInSource && loc.SourceTree == semanticModel.SyntaxTree).FirstOrDefault();
this.isVerbatim = this.replacementText.StartsWith("@");
this.simplificationService = LanguageService.GetService<ISimplificationService>(parameters.Document);
}
public override void VisitAlias(IAliasSymbol symbol)
{
base.VisitAlias(symbol);
}
public sealed override void VisitAlias(IAliasSymbol symbol)
{
Visit(symbol.Target);
}
public override void VisitAlias(IAliasSymbol symbol)
{
builder.Add(CreatePart(SymbolDisplayPartKind.AliasName, symbol, symbol.Name));
if (format.LocalOptions.IncludesOption(SymbolDisplayLocalOptions.IncludeType))
{
// ???
AddPunctuation(SyntaxKind.EqualsToken);
symbol.Target.Accept(this);
}
}
public static void Create(IAliasSymbol symbol, SymbolKeyWriter visitor)
{
visitor.WriteString(symbol.Name);
visitor.WriteSymbolKey(symbol.Target);
visitor.WriteString(symbol.DeclaringSyntaxReferences.FirstOrDefault()?.SyntaxTree.FilePath ?? "");
}
public override void VisitAlias(IAliasSymbol symbol)
{
// TODO(cyrusn): I don't think we need to inspect the target of an alias.
}
public virtual void VisitAlias(IAliasSymbol symbol)
{
DefaultVisit(symbol);
}
