public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { IdentifierNameSyntax processedNode = (IdentifierNameSyntax)base.VisitIdentifierName(node); ISymbol symbol = this.model.GetSymbolInfo(node, this.cancellationToken).Symbol; // If this is reference to renamed symbol, replace identifier if (this.renamedSymbol.Equals(symbol)) { SyntaxToken identifier = node.Identifier; SyntaxToken newIdentifier = Syntax.Identifier(identifier.LeadingTrivia, this.newName, identifier.TrailingTrivia); IdentifierNameSyntax newIdentifierName = processedNode.WithIdentifier(newIdentifier); return newIdentifierName; } else if (node.Identifier.ValueText == this.newName) { // If the Identifier refers to type name within variable declaration, no action is undertaken // Consider: // newVariableName myVariable; -> type name can remain as is if (node.Ancestors().OfType<VariableDeclarationSyntax>().Any(n => n.Type.DescendantNodesAndSelf().Contains(node))) { return processedNode; } // If it is not a top-most expression of MemberAccessExpression, don't qualify if (node.Ancestors().OfType<MemberAccessExpressionSyntax>().Any(n => n.Name.DescendantNodesAndSelf().Contains(node))) { return processedNode; } ExpressionSyntax qualifier = null; if (symbol.IsStatic) { // If symbol is static, qualify the reference with containing type's name qualifier = Syntax.ParseTypeName(symbol.ContainingType.ToMinimalDisplayString(node.GetLocation(), this.model)); } else { // If symbol is instance, qualify the reference with `this' keyword qualifier = Syntax.ThisExpression(); } MemberAccessExpressionSyntax memberAccess = Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, qualifier, processedNode); return memberAccess; } return processedNode; }
static public Maybe <FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError> > GetIdentifierDeclarationSyntax(IdentifierNameSyntax syntax, MethodBlockAnalysis methodAnalysis) { Maybe <FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError> > __Ok(IXor4IdentifierOriginSyntax ok) => new FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError>(ok); Maybe <FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError> > __Error(SimpleControlFlowAnalysisError error) => new FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError>(error); var loopLikeSyntax = syntax.Ancestors().FirstOrDefault(x => SyntaxOperations.IsLoopLike(x)); if (loopLikeSyntax != null) { return(__Error(SimpleControlFlowAnalysisError.NotALinearControlFlow(loopLikeSyntax))); } else { var symbolInfo = methodAnalysis.SemanticModel.GetSymbolInfo(syntax); switch (symbolInfo.Symbol.Kind) { case SymbolKind.NamedType: case SymbolKind.Namespace: { return(Maybe.NoValue); } case SymbolKind.Local: { var declaratorSyntax = (VariableDeclaratorSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax(); var delarationSyntax = declaratorSyntax.Ancestors().OfType <LocalDeclarationStatementSyntax>().First(); return(__Ok(new Xor4IdentifierOriginSyntax(delarationSyntax))); } case SymbolKind.Field: { var declaringSyntax = (FieldDeclarationSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax(); return(__Ok(new Xor4IdentifierOriginSyntax(declaringSyntax))); } case SymbolKind.Property: { var declaringSyntax = (PropertyDeclarationSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax(); return(__Ok(new Xor4IdentifierOriginSyntax(declaringSyntax))); } case SymbolKind.Parameter: { var declaringSyntax = (ParameterSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax(); return(__Ok(new Xor4IdentifierOriginSyntax(declaringSyntax))); } default: throw NotPreparedForThatCase.UnexpectedEnumException(symbolInfo.Symbol.Kind); } } }
private static bool HasConflict( IdentifierNameSyntax identifier, VariableDeclaratorSyntax variableDeclarator ) { // TODO: Check for more conflict types. if (identifier.SpanStart < variableDeclarator.SpanStart) { return(true); } var identifierNode = identifier .Ancestors() .TakeWhile( n => n.Kind() == SyntaxKind.ParenthesizedExpression || n.Kind() == SyntaxKind.CastExpression ) .LastOrDefault(); if (identifierNode == null) { identifierNode = identifier; } if (identifierNode.IsParentKind(SyntaxKind.Argument, out ArgumentSyntax argument)) { if (argument.RefOrOutKeyword.Kind() != SyntaxKind.None) { return(true); } } else if ( identifierNode.Parent.IsKind( SyntaxKind.PreDecrementExpression, SyntaxKind.PreIncrementExpression, SyntaxKind.PostDecrementExpression, SyntaxKind.PostIncrementExpression, SyntaxKind.AddressOfExpression ) ) { return(true); } else if (identifierNode.Parent is AssignmentExpressionSyntax binaryExpression) { if (binaryExpression.Left == identifierNode) { return(true); } } return(false); }
public override void VisitIdentifierName(IdentifierNameSyntax node) { base.VisitIdentifierName(node); var ancestors = node.Ancestors(); if (ancestors.Any(n => (n is MemberAccessExpressionSyntax) || (n is InvocationExpressionSyntax))) { return; } Check(node); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { ISymbol referencedSymbol = this.model.GetSymbolInfo(node, this.cancellationToken).Symbol; // Static members don't have to be qualified if (referencedSymbol == null || referencedSymbol.IsStatic) { return(base.VisitIdentifierName(node)); } // Check is the name already qualified. If so, no further action is needed (only top-most identifier may be qualified) // Considers: // a.>b<.foo() -> a.b.foo() if (node.Ancestors().OfType <MemberAccessExpressionSyntax>().Any(n => n.Name.DescendantNodesAndSelf().Contains(node))) { return(base.VisitIdentifierName(node)); } // Considers: // >a<.b.foo() -> newParameter.a.b.foo() if (referencedSymbol.Kind == CommonSymbolKind.Field || referencedSymbol.Kind == CommonSymbolKind.Method || referencedSymbol.Kind == CommonSymbolKind.Property || referencedSymbol.Kind == CommonSymbolKind.Event) { // Special case: constructor of different type is an unqualified and non-static member if (referencedSymbol.Kind == CommonSymbolKind.Method) { MethodSymbol method = (MethodSymbol)referencedSymbol; if (method.MethodKind == MethodKind.Constructor) { return(base.VisitIdentifierName(node)); } } // Create new context with leading trivia of old context IdentifierNameSyntax parameterIdentifier = Syntax.IdentifierName(this.newParameterNameToken) .WithLeadingTrivia(node.GetLeadingTrivia()); // And remove leading trivia from old context IdentifierNameSyntax context = node.WithLeadingTrivia(); return(Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, parameterIdentifier, context)); } return(base.VisitIdentifierName(node)); }
private Task <Solution> CreateRecordAttributeDeclarationDocument(Document document, IdentifierNameSyntax declaration, CancellationToken cancellationToken) { // get the namespace of document or namespace from attribute usage var namespaces = declaration .Ancestors() .OfType <NamespaceDeclarationSyntax>() .Reverse() .Select(nsSyntax => nsSyntax.Name.ToString()) .ToArray(); var targetNamespace = string.Join(".", namespaces); var text = RecordAttributeDeclarationSource(targetNamespace); var tree = CSharpSyntaxTree.ParseText(text, cancellationToken: cancellationToken); var formattedRoot = Formatter.Format(tree.GetRoot(), document.Project.Solution.Workspace, cancellationToken: cancellationToken); var doc = document.Project.AddDocument(RecordAttributeProperties.Filename, formattedRoot, document.Folders); return(Task.FromResult(doc.Project.Solution)); }