private SyntaxNode GetWriteExpression( TExpressionSyntax writeValue, bool keepTrivia, string?conflictMessage ) { if (ShouldWriteToBackingField()) { var newIdentifierToken = AddConflictAnnotation( Generator.Identifier(_propertyBackingField.Name), conflictMessage ); var newIdentifierName = QualifyIfAppropriate( Generator.IdentifierName(newIdentifierToken) ); if (keepTrivia) { newIdentifierName = newIdentifierName.WithTriviaFrom(_identifierName); } return(Generator.AssignmentStatement( _expression.ReplaceNode(_identifierName, newIdentifierName), writeValue )); } else { return(GetSetInvocationExpression(writeValue, keepTrivia, conflictMessage)); } }
public ReferenceReplacer( AbstractReplacePropertyWithMethodsService <TIdentifierNameSyntax, TExpressionSyntax, TCrefSyntax, TStatementSyntax, TPropertySyntax> service, SemanticModel semanticModel, ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, SyntaxEditor editor, TIdentifierNameSyntax identifierName, IPropertySymbol property, IFieldSymbol propertyBackingField, string desiredGetMethodName, string desiredSetMethodName, CancellationToken cancellationToken) { _service = service; _semanticModel = semanticModel; _syntaxFacts = syntaxFacts; _semanticFacts = semanticFacts; _editor = editor; _identifierName = identifierName; _property = property; _propertyBackingField = propertyBackingField; _desiredGetMethodName = desiredGetMethodName; _desiredSetMethodName = desiredSetMethodName; _cancellationToken = cancellationToken; _expression = _identifierName; _cref = _service.TryGetCrefSyntax(_identifierName); if (_syntaxFacts.IsNameOfMemberAccessExpression(_expression)) { _expression = (TExpressionSyntax)_expression.Parent !; } }
private string CreateDisplayText(TExpressionSyntax expression) { var singleLineExpression = _semanticDocument.Document.GetLanguageService <ISyntaxFactsService>().ConvertToSingleLine(expression); var nodeString = singleLineExpression.ToString(); return(CreateDisplayText(nodeString)); }
public ReferenceReplacer( AbstractReplacePropertyWithMethodsService <TIdentifierNameSyntax, TExpressionSyntax, TStatementSyntax> service, SemanticModel semanticModel, ISyntaxFactsService syntaxFacts, ISemanticFactsService semanticFacts, SyntaxEditor editor, SyntaxToken nameToken, IPropertySymbol property, IFieldSymbol propertyBackingField, string desiredGetMethodName, string desiredSetMethodName, CancellationToken cancellationToken) { _service = service; _semanticModel = semanticModel; _syntaxFacts = syntaxFacts; _semanticFacts = semanticFacts; _editor = editor; _nameToken = nameToken; _property = property; _propertyBackingField = propertyBackingField; _desiredGetMethodName = desiredGetMethodName; _desiredSetMethodName = desiredSetMethodName; _cancellationToken = cancellationToken; _identifierName = (TIdentifierNameSyntax)nameToken.Parent; _expression = _identifierName; if (_syntaxFacts.IsMemberAccessExpressionName(_expression)) { _expression = _expression.Parent as TExpressionSyntax; } }
static bool IsInitializerOfConstant(SemanticDocument document, TExpressionSyntax expression) { var syntaxFacts = document.Document.GetRequiredLanguageService <ISyntaxFactsService>(); var current = expression; while (syntaxFacts.IsParenthesizedExpression(current.Parent)) { current = (TExpressionSyntax)current.Parent; } if (!syntaxFacts.IsEqualsValueClause(current.Parent)) { return(false); } var equalsValue = current.Parent; if (!syntaxFacts.IsVariableDeclarator(equalsValue.Parent)) { return(false); } var declaration = equalsValue.AncestorsAndSelf().FirstOrDefault(n => syntaxFacts.IsLocalDeclarationStatement(n) || syntaxFacts.IsFieldDeclaration(n)); if (declaration == null) { return(false); } var generator = SyntaxGenerator.GetGenerator(document.Document); return(generator.GetModifiers(declaration).IsConst); }
private SyntaxNode GetSetInvocationExpression( TExpressionSyntax writeValue, bool keepTrivia, string?conflictMessage) { return(GetInvocationExpression(_desiredSetMethodName, argument: Generator.Argument(writeValue), keepTrivia: keepTrivia, conflictMessage: conflictMessage)); }
protected IEnumerable <ITypeSymbol> GetTypes(TExpressionSyntax expression, bool objectAsDefault = false) { if (_seenExpressionGetType.Add(expression)) { return(GetTypes_DoNotCallDirectly(expression, objectAsDefault)); } return(SpecializedCollections.EmptyEnumerable <ITypeSymbol>()); }
public InlineMethodContext( ImmutableArray <TStatementSyntax> statementsToInsertBeforeInvocationOfCallee, TExpressionSyntax inlineExpression, bool containsAwaitExpression) { StatementsToInsertBeforeInvocationOfCallee = statementsToInsertBeforeInvocationOfCallee; InlineExpression = inlineExpression; ContainsAwaitExpression = containsAwaitExpression; }
static bool IsExpressionConstant( SemanticDocument document, TExpressionSyntax expression, TService service, CancellationToken cancellationToken ) { if ( document.SemanticModel.GetConstantValue(expression, cancellationToken) is { HasValue : true, Value : var value }
internal IntroduceVariableAllOccurrenceCodeAction( TService service, SemanticDocument document, TExpressionSyntax expression, bool allOccurrences, bool isConstant, bool isLocal, bool isQueryLocal) : base(service, document, expression, allOccurrences, isConstant, isLocal, isQueryLocal) { }
public static ImmutableHashSet <ISymbol> GetAllSymbols( SemanticModel semanticModel, TExpressionSyntax methodDeclarationSyntax, CancellationToken cancellationToken) { var visitor = new LocalVariableDeclarationVisitor(cancellationToken); var operation = semanticModel.GetOperation(methodDeclarationSyntax, cancellationToken); visitor.Visit(operation); return(visitor._allSymbols.ToImmutableHashSet()); }
public IEnumerable <ITypeSymbol> InferTypes(TExpressionSyntax expression, bool filterUnusable = true) { if (expression != null) { if (_seenExpressionInferType.Add(expression)) { var types = InferTypesWorker_DoNotCallDirectly(expression); return(Filter(types, filterUnusable)); } } return(SpecializedCollections.EmptyEnumerable <ITypeSymbol>()); }
public ImmutableArray <TypeInferenceInfo> InferTypes(TExpressionSyntax expression, bool filterUnusable = true) { if (expression != null) { if (_seenExpressionInferType.Add(expression)) { var types = InferTypesWorker_DoNotCallDirectly(expression); return(Filter(types, filterUnusable)); } } return(ImmutableArray <TypeInferenceInfo> .Empty); }
private string CreateDisplayText(TExpressionSyntax expression) { var singleLineExpression = _document.Project.LanguageServices.GetService <ISyntaxFactsService>().ConvertToSingleLine(expression); var nodeString = singleLineExpression.ToString(); // prevent the display string from being too long const int MaxLength = 40; if (nodeString.Length > MaxLength) { nodeString = nodeString.Substring(0, MaxLength) + "..."; } return(CreateDisplayText(nodeString)); }
private string CreateDisplayText(TExpressionSyntax expression) { var singleLineExpression = this.document.Project.LanguageServices.GetService <ISyntaxFactsService>().ConvertToSingleLine(expression); var nodeString = singleLineExpression.ToFullString().Trim(); // prevent the display string from spanning multiple lines nodeString = newlinePattern.Replace(nodeString, " "); // prevent the display string from being too long const int MaxLength = 40; if (nodeString.Length > MaxLength) { nodeString = nodeString.Substring(0, MaxLength) + "..."; } return(CreateDisplayText(nodeString)); }
internal AbstractIntroduceVariableCodeAction( TService service, SemanticDocument document, TExpressionSyntax expression, bool allOccurrences, bool isConstant, bool isLocal, bool isQueryLocal) { _service = service; _document = document; _expression = expression; _allOccurrences = allOccurrences; _isConstant = isConstant; _isLocal = isLocal; _isQueryLocal = isQueryLocal; _title = CreateDisplayText(expression); }
private string CreateDisplayText(TExpressionSyntax expression) { var singleLineExpression = expression.ConvertToSingleLine(); var nodeString = singleLineExpression.ToFullString().Trim(); // prevent the display string from spanning multiple lines nodeString = s_newlinePattern.Replace(nodeString, " "); // prevent the display string from being too long const int MaxLength = 40; if (nodeString.Length > MaxLength) { nodeString = nodeString.Substring(0, MaxLength) + "..."; } return(CreateDisplayText(nodeString)); }
private bool DetermineNamespaceOrTypeToGenerateIn( TService service, SemanticModel semanticModel, TExpressionSyntax leftSide, CancellationToken cancellationToken) { var leftSideInfo = semanticModel.GetSymbolInfo(leftSide, cancellationToken); if (leftSideInfo.Symbol != null) { var symbol = leftSideInfo.Symbol; if (symbol is INamespaceSymbol) { this.NamespaceToGenerateInOpt = symbol.ToNameDisplayString(); return(true); } else if (symbol is INamedTypeSymbol) { // TODO: Code coverage this.TypeToGenerateInOpt = (INamedTypeSymbol)symbol.OriginalDefinition; return(true); } // We bound to something other than a namespace or named type. Can't generate a // type inside this. return(false); } else { // If it's a dotted name, then perhaps it's a namespace. i.e. the user wrote // "new Foo.Bar.Baz()". In this case we want to generate a namespace for // "Foo.Bar". IList <string> nameParts; if (service.TryGetNameParts(leftSide, out nameParts)) { this.NamespaceToGenerateInOpt = string.Join(".", nameParts); return(true); } } return(false); }
public IntroduceParameterDocumentRewriter(AbstractIntroduceParameterService <TExpressionSyntax, TInvocationExpressionSyntax, TObjectCreationExpressionSyntax, TIdentifierNameSyntax> service, Document originalDocument, TExpressionSyntax expression, IMethodSymbol methodSymbol, SyntaxNode containingMethod, IntroduceParameterCodeActionKind selectedCodeAction, bool allOccurrences) { _service = service; _originalDocument = originalDocument; _generator = SyntaxGenerator.GetGenerator(originalDocument); _syntaxFacts = originalDocument.GetRequiredLanguageService <ISyntaxFactsService>(); _semanticFacts = originalDocument.GetRequiredLanguageService <ISemanticFactsService>(); _expression = expression; _methodSymbol = methodSymbol; _containerMethod = containingMethod; _actionKind = selectedCodeAction; _allOccurrences = allOccurrences; }
protected abstract SyntaxNode GetExpression(TExpressionSyntax expression);
protected abstract IEnumerable <TypeInferenceInfo> GetTypes_DoNotCallDirectly(TExpressionSyntax expression, bool objectAsDefault);
private bool TryInitializeIdentifierName( TService service, SemanticDocument semanticDocument, TSimpleNameSyntax identifierName, CancellationToken cancellationToken) { this.SimpleName = identifierName; if (!service.TryInitializeIdentifierNameState(semanticDocument, identifierName, cancellationToken, out var identifierToken, out var simpleNameOrMemberAccessExpression)) { return(false); } this.IdentifierToken = identifierToken; this.SimpleNameOrMemberAccessExpression = simpleNameOrMemberAccessExpression; var semanticModel = semanticDocument.SemanticModel; var semanticFacts = semanticDocument.Document.GetLanguageService <ISemanticFactsService>(); var syntaxFacts = semanticDocument.Document.GetLanguageService <ISyntaxFactsService>(); if (semanticFacts.IsWrittenTo(semanticModel, this.SimpleNameOrMemberAccessExpression, cancellationToken) || syntaxFacts.IsInNamespaceOrTypeContext(this.SimpleNameOrMemberAccessExpression)) { return(false); } // Now, try to bind the invocation and see if it succeeds or not. if it succeeds and // binds uniquely, then we don't need to offer this quick fix. cancellationToken.ThrowIfCancellationRequested(); var containingType = semanticModel.GetEnclosingNamedType(identifierToken.SpanStart, cancellationToken); if (containingType == null) { return(false); } var semanticInfo = semanticModel.GetSymbolInfo(this.SimpleNameOrMemberAccessExpression, cancellationToken); if (cancellationToken.IsCancellationRequested) { return(false); } if (semanticInfo.Symbol != null) { return(false); } // Either we found no matches, or this was ambiguous. Either way, we might be able // to generate a method here. Determine where the user wants to generate the method // into, and if it's valid then proceed. if (!service.TryDetermineTypeToGenerateIn( semanticDocument, containingType, simpleNameOrMemberAccessExpression, cancellationToken, out var typeToGenerateIn, out var isStatic)) { return(false); } if (!isStatic) { return(false); } this.TypeToGenerateIn = typeToGenerateIn; return(true); }
public Relational(BinaryOperatorKind operatorKind, TExpressionSyntax value) { OperatorKind = operatorKind; Value = value; }
public Argument(RefKind refKind, string name, TExpressionSyntax expression) { RefKind = refKind; Name = name ?? ""; Expression = expression; }
public Range(TExpressionSyntax lowerBound, TExpressionSyntax higherBound) { LowerBound = lowerBound; HigherBound = higherBound; }
protected abstract IEnumerable <ITypeSymbol> GetTypes_DoNotCallDirectly(TExpressionSyntax expression, bool objectAsDefault);
protected abstract IEnumerable <ITypeSymbol> InferTypesWorker_DoNotCallDirectly(TExpressionSyntax expression);
public Constant(TExpressionSyntax expression) => ExpressionSyntax = expression;
protected abstract IEnumerable <TypeInferenceInfo> InferTypesWorker_DoNotCallDirectly(TExpressionSyntax expression);