public static LocalDeclarationStatementSyntax DeclareLocalVariable(Type variableType, string name, ExpressionSyntax initValue = null, VariableDeclarationType variableDeclarationType = VariableDeclarationType.ExplicitType) { VariableDeclaratorSyntax varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(name)); if (variableType.IsVsArrayType()) { ObjectCreationExpressionSyntax exp = SyntaxFactory.ObjectCreationExpression(variableType.ToTypeSyntax()) .WithArgumentList(SyntaxFactory.ArgumentList()); varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(exp)); } else if (initValue != null) { varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(initValue)); } VariableDeclarationSyntax varDeclaration = variableDeclarationType == VariableDeclarationType.InferredType ? SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var")) : SyntaxFactory.VariableDeclaration(variableType.ToTypeSyntax()); varDeclaration = varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator)); return(SyntaxFactory.LocalDeclarationStatement(varDeclaration)); }
public static VariableDeclaratorSyntax WithInitialValue( this VariableDeclaratorSyntax parentSyntax, ExpressionSyntax childSyntax) { if (childSyntax == null) { return(parentSyntax.WithInitializer(null)); } EqualsValueClauseSyntax valueSyntax = parentSyntax.Initializer; return(valueSyntax == null? parentSyntax.WithInitializer(SyntaxFactory.EqualsValueClause(childSyntax)) : parentSyntax.WithInitializer(parentSyntax.Initializer.WithValue(childSyntax))); }
private static VariableDeclaratorSyntax FieldConstDeclaration(ConstDeclaration constDeclaration, VariableDeclaratorSyntax varDeclarator) { var assignment = constDeclaration.Type.Type switch { BaseTypes.Int => SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression( SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(constDeclaration.Value.ToInt32()))), BaseTypes.Bool => SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression( constDeclaration.Value.ToBool() ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression)), BaseTypes.Real => SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression( SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(constDeclaration.Value.ToDouble()))), _ => throw new ArgumentException( "Cannot handle type " + Enum.GetName(typeof(BaseTypes), constDeclaration.Type.Type), nameof(constDeclaration)) }; return(varDeclarator.WithInitializer(assignment)); }
/// <summary> /// System.Object paramName [= ...]; /// </summary> protected internal virtual LocalDeclarationStatementSyntax DeclareLocal(ITypeInfo type, string name, ExpressionSyntax?initializer = null) { VariableDeclaratorSyntax declarator = VariableDeclarator ( identifier: Identifier(name) ); if (initializer != null) { declarator = declarator.WithInitializer ( initializer: EqualsValueClause ( initializer ) ); } return(LocalDeclarationStatement ( declaration: VariableDeclaration ( type: CreateType(type), variables: SeparatedList(new List <VariableDeclaratorSyntax> { declarator }) ) )); }
protected LocalDeclarationStatementSyntax ResolveLocal(ITypeInfo type, string name, ExpressionSyntax?initializer = null) { VariableDeclaratorSyntax declarator = VariableDeclarator ( identifier: Identifier(name) ); if (initializer is not null) { declarator = declarator.WithInitializer ( initializer: EqualsValueClause ( initializer ) ); } return(LocalDeclarationStatement ( declaration: VariableDeclaration ( type: ResolveType(type), variables: SingletonSeparatedList(declarator) ) )); }
public override SyntaxNode VisitVariableDeclarator(VariableDeclaratorSyntax node) { if (node.Initializer == null) { return(base.VisitVariableDeclarator(node)); } if (node.Parent is VariableDeclarationSyntax == false) { return(base.VisitVariableDeclarator(node)); } if (node.Parent.Parent is FieldDeclarationSyntax == false) { return(base.VisitVariableDeclarator(node)); } if ((node.Parent.Parent as FieldDeclarationSyntax).Modifiers.Any(x => x.ValueText == "const")) { return(base.VisitVariableDeclarator(node)); } var value = node.Initializer.Value; if (value is LiteralExpressionSyntax) { var variableTypeNode = GetSystemTypeOfTypeNode((node.Parent as VariableDeclarationSyntax)); var valueObj = (value as LiteralExpressionSyntax).Token.Value; if (TypesMapItem.GetAllPredefinedTypesDic().ContainsKey(variableTypeNode)) { var typeItem = TypesMapItem.GetAllPredefinedTypesDic()[variableTypeNode]; if ((typeItem.DefaultValue == null && valueObj != null) || (typeItem.DefaultValue != null && !typeItem.DefaultValue.Equals(valueObj))) { return(base.VisitVariableDeclarator(node)); } } else { if (valueObj != null) { return(base.VisitVariableDeclarator(node)); } } node = node.WithInitializer(null).WithoutTrailingTrivia(); } //else if (value is DefaultExpressionSyntax) //{ // node = node.WithInitializer(null).WithoutTrailingTrivia(); //} //else if (value is ObjectCreationExpressionSyntax) //{ // if (variableTypeNode.IsKind(SyntaxKind.PredefinedType)) // { // node = node.WithInitializer(null).WithoutTrailingTrivia(); // } //} return(base.VisitVariableDeclarator(node)); }
/// <summary> /// Declares the variables in the field along with their initializers. /// <para>In the example "private int testInt = 0", "testInt" would be the variable. </para> /// </summary> private static VariableDeclaratorSyntax CreateVariableDeclaratorSyntax(FieldGenerationData data) { VariableDeclaratorSyntax declaratorSyntax = SyntaxFactory.VariableDeclarator(data.m_VariableName); if (!data.m_UseInitializer) { return(declaratorSyntax); } if (VariableTypeCheckerUtility.IsVariableInitializableWithoutNewKeyword(data.m_VariableType)) { return(declaratorSyntax.WithInitializer(CreateFieldInitializer(data))); } else { return(declaratorSyntax.WithInitializer(CreateNewFieldInitializer(data))); } }
public static Task <Document> RemoveRedundantAssignmentAfterLocalDeclarationAsync( Document document, VariableDeclaratorSyntax declarator, CancellationToken cancellationToken = default) { var declaration = (VariableDeclarationSyntax)declarator.Parent; var localDeclaration = (LocalDeclarationStatementSyntax)declaration.Parent; StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(localDeclaration); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(localDeclaration); StatementSyntax nextStatement = statements[index + 1]; var expressionStatement = (ExpressionStatementSyntax)nextStatement; var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression; ExpressionSyntax right = assignment.Right; EqualsValueClauseSyntax initializer = declarator.Initializer; ExpressionSyntax value = initializer?.Value; VariableDeclaratorSyntax newDeclarator = (value != null) ? declarator.ReplaceNode(value, right) : declarator.WithInitializer(EqualsValueClause(right)); LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration.ReplaceNode(declarator, newDeclarator); SyntaxTriviaList trailingTrivia = localDeclaration.GetTrailingTrivia(); if (!trailingTrivia.IsEmptyOrWhitespace()) { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trailingTrivia.Concat(nextStatement.GetTrailingTrivia())); } else { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(nextStatement.GetTrailingTrivia()); } SyntaxTriviaList leadingTrivia = nextStatement.GetLeadingTrivia(); if (!leadingTrivia.IsEmptyOrWhitespace()) { newLocalDeclaration = newLocalDeclaration.WithLeadingTrivia(newLocalDeclaration.GetLeadingTrivia().Concat(leadingTrivia)); } SyntaxList <StatementSyntax> newStatements = statements .Replace(localDeclaration, newLocalDeclaration) .RemoveAt(index + 1); return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); }
public static Task <Document> RefactorAsync( Document document, VariableDeclaratorSyntax declarator, CancellationToken cancellationToken) { var declaration = (VariableDeclarationSyntax)declarator.Parent; var localDeclaration = (LocalDeclarationStatementSyntax)declaration.Parent; StatementContainer container = StatementContainer.Create(localDeclaration); SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(localDeclaration); StatementSyntax nextStatement = statements[index + 1]; var expressionStatement = (ExpressionStatementSyntax)nextStatement; var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression; ExpressionSyntax right = assignment.Right; EqualsValueClauseSyntax initializer = declarator.Initializer; ExpressionSyntax value = initializer?.Value; VariableDeclaratorSyntax newDeclarator = (value != null) ? declarator.ReplaceNode(value, right) : declarator.WithInitializer(EqualsValueClause(right)); LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration.ReplaceNode(declarator, newDeclarator); SyntaxTriviaList trailingTrivia = localDeclaration.GetTrailingTrivia(); if (trailingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia())) { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trailingTrivia.Concat(nextStatement.GetTrailingTrivia())); } else { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(nextStatement.GetTrailingTrivia()); } SyntaxTriviaList leadingTrivia = nextStatement.GetLeadingTrivia(); if (leadingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia())) { newLocalDeclaration = newLocalDeclaration.WithLeadingTrivia(newLocalDeclaration.GetLeadingTrivia().Concat(leadingTrivia)); } SyntaxList <StatementSyntax> newStatements = statements .Replace(localDeclaration, newLocalDeclaration) .RemoveAt(index + 1); return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
public static VariableDeclaratorSyntax WithSuppressNullableWarningExpression( this VariableDeclaratorSyntax variable) => variable .WithInitializer( EqualsValueClause( PostfixUnaryExpression( SyntaxKind.SuppressNullableWarningExpression, LiteralExpression( SyntaxKind.DefaultLiteralExpression, Token(SyntaxKind.DefaultKeyword)))));
public CSharpSyntaxNode Convert(VariableDeclarationNode node) { //TODO: name is ArrayBindingPattern VariableDeclaratorSyntax csVariable = SyntaxFactory.VariableDeclarator(node.Name.Text); if (node.Initializer != null) { csVariable = csVariable.WithInitializer(SyntaxFactory.EqualsValueClause(node.Initializer.ToCsNode <ExpressionSyntax>())); } return(csVariable); }
public override SyntaxNode VisitVariableDeclarator(VariableDeclaratorSyntax node) { if (node.Identifier.ValueText == _variableName) { return(node.WithInitializer( node.Initializer.WithValue( SyntaxFactory.LiteralExpression(_kind, _creator()) ) )); } return(base.VisitVariableDeclarator(node)); }
public SyntaxNode Substitute() { var literal = TryCreateLiteral(); if (literal != null) { return(node.WithInitializer(SyntaxFactory.EqualsValueClause(literal))); } Log.Trace(string.Format("Matched field {0} with substitution coming from cmd line but type conversion failed", symbol)); return(node); }
protected override LocalDeclarationStatementSyntax CreateNewStatement() { ConditionalExpressionSyntax conditionalExpression = IfRefactoringHelper.CreateConditionalExpression(IfStatement.Condition, WhenTrue, WhenFalse); VariableDeclaratorSyntax declarator = Statement.Declaration.Variables[0]; EqualsValueClauseSyntax initializer = declarator.Initializer; EqualsValueClauseSyntax newInitializer = (initializer != null) ? initializer.WithValue(conditionalExpression) : EqualsValueClause(conditionalExpression); return(Statement.ReplaceNode(declarator, declarator.WithInitializer(newInitializer))); }
/// <summary> /// Normalizes the <paramref name="declaration" />. /// </summary> public override SyntaxNode VisitVariableDeclarator(VariableDeclaratorSyntax declaration) { var objectCreation = declaration?.Initializer?.Value as ObjectCreationExpressionSyntax; if (objectCreation == null) { return(declaration); } var symbol = SemanticModel.GetDeclaredSymbol(declaration); if (symbol == null) { return(declaration); } ITypeSymbol type; string name; switch (symbol.Kind) { case SymbolKind.Field: var fieldSymbol = ((IFieldSymbol)symbol); type = fieldSymbol.Type; name = fieldSymbol.Name; break; case SymbolKind.Local: var localSymbol = ((ILocalSymbol)symbol); type = localSymbol.Type; name = localSymbol.Name; break; default: return(declaration); } var fault = SemanticModel.GetTypeSymbol <Fault>(); if (!type.Equals(fault) && !type.IsDerivedFrom(fault)) { return(declaration); } return(declaration.WithInitializer(declaration.Initializer.WithValue(AddNameInitializer(fault, objectCreation, name)))); }
private static StatementSyntax CreateStaticDefinitionId(DatasetDefinition datasetDefinition) { SyntaxToken token = SyntaxFactory.Literal(datasetDefinition.Id); VariableDeclaratorSyntax variable = SyntaxFactory.VariableDeclarator( SyntaxFactory.SingletonSeparatedList(SyntaxFactory.ModifiedIdentifier("DatasetDefinitionId"))); variable = variable.WithAsClause( SyntaxFactory.SimpleAsClause(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)))); variable = variable.WithInitializer( SyntaxFactory.EqualsValue(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, token))); return(SyntaxFactory.FieldDeclaration( SyntaxFactory.List <AttributeListSyntax>(), SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.SharedKeyword)), SyntaxFactory.SingletonSeparatedList(variable))); }
public static FieldDeclarationSyntax DeclareField(Type fieldType, string name, AccessibilityFlags accessibility = AccessibilityFlags.Default) { VariableDeclarationSyntax varDeclaration = SyntaxFactory.VariableDeclaration(fieldType.ToTypeSyntax()); VariableDeclaratorSyntax varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(name)); if (fieldType.IsVsArrayType()) { ObjectCreationExpressionSyntax exp = SyntaxFactory.ObjectCreationExpression(fieldType.ToTypeSyntax()) .WithArgumentList(SyntaxFactory.ArgumentList()); varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(exp)); } FieldDeclarationSyntax fieldDeclaration = SyntaxFactory.FieldDeclaration( varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator))) .WithModifiers(SyntaxFactory.TokenList(AccessibilityToSyntaxToken(accessibility).ToArray())); return(fieldDeclaration); }
public static LocalDeclarationStatementSyntax Declare(TypeSyntax typeSyntax, string identifier, bool initializeToDefault) { VariableDeclaratorSyntax decl = VariableDeclarator(identifier); if (initializeToDefault) { decl = decl.WithInitializer( EqualsValueClause( LiteralExpression(SyntaxKind.DefaultLiteralExpression))); } // <type> <identifier>; // or // <type> <identifier> = default; return(LocalDeclarationStatement( VariableDeclaration( typeSyntax, SingletonSeparatedList(decl)))); }
public static LocalDeclarationStatementSyntax DeclareLocalVariable(string typeName, string variableName, ExpressionSyntax initValue = null, VariableDeclarationType variableDeclarationType = VariableDeclarationType.ExplicitType) { VariableDeclaratorSyntax varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(variableName)); if (initValue != null) { varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(initValue)); } VariableDeclarationSyntax varDeclaration = variableDeclarationType == VariableDeclarationType.InferredType ? SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var")) : SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(typeName)); varDeclaration = varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator)); return(SyntaxFactory.LocalDeclarationStatement(varDeclaration)); }
public static LocalDeclarationStatementSyntax Declare(TypeSyntax typeSyntax, string identifier, ExpressionSyntax?initializer) { VariableDeclaratorSyntax decl = VariableDeclarator(identifier); if (initializer is not null) { decl = decl.WithInitializer( EqualsValueClause( initializer)); } // <type> <identifier>; // or // <type> <identifier> = <initializer>; return(LocalDeclarationStatement( VariableDeclaration( typeSyntax, SingletonSeparatedList(decl)))); }
private static StatementSyntax GetRequestInitialization(SyntaxToken queryStringDictToken, SyntaxToken bodyDictToken, VariableDeclaratorSyntax descriptorDeclaration, VariableDeclaratorSyntax requestDeclaration) { var remoteRequestArguments = ArgumentList(SeparatedList( new[] { Argument(IdentifierName(descriptorDeclaration.Identifier)), Argument(GetCallingExpression(queryStringDictToken, nameof(ImmutableDictionary <string, object> .Builder.ToImmutable))), Argument(GetCallingExpression(bodyDictToken, nameof(ImmutableDictionary <string, object> .Builder.ToImmutable))) } )); var requestInitializer = EqualsValueClause(InvocationExpression(ObjectCreationExpression(ParseTypeName(nameof(RemoteRequest))), remoteRequestArguments)); var requestInitialization = LocalDeclarationStatement(VariableDeclaration(ParseTypeName("var")) .AddVariables(requestDeclaration.WithInitializer(requestInitializer))); return(requestInitialization); }
private static VariableDeclaratorSyntax GetNewDeclarator( VariableDeclaratorSyntax declarator, TypeSyntax type, ITypeSymbol typeSymbol) { ExpressionSyntax value = SyntaxUtility.CreateDefaultValue(typeSymbol, type); EqualsValueClauseSyntax @default = EqualsValueClause(value); if (declarator.Initializer == null || declarator.Initializer.IsMissing) { return(declarator .WithIdentifier(declarator.Identifier.WithoutTrailingTrivia()) .WithInitializer(@default.WithTrailingTrivia(declarator.Identifier.TrailingTrivia))); } else { return(declarator .WithInitializer(@default.WithTriviaFrom(declarator.Initializer.EqualsToken))); } }
private static StatementSyntax GetDescriptorInitialization(IReadOnlyDictionary <string, object> attributeData, VariableDeclaratorSyntax descriptorDeclaration) { if (!attributeData.ContainsKey(nameof(WebInvokeAttribute.Method))) { throw new InvalidOperationException("Cannot generate call without specifying HTTP method"); } if (!attributeData.TryGetValue(nameof(WebInvokeAttribute.UriTemplate), out var uriTemplate)) { uriTemplate = string.Empty; } if (!attributeData.TryGetValue(nameof(WebInvokeAttribute.RequestFormat), out var requestFormat)) { requestFormat = default(OperationWebMessageFormat); } if (!attributeData.TryGetValue(nameof(WebInvokeAttribute.ResponseFormat), out var responseFormat)) { responseFormat = default(OperationWebMessageFormat); } var remoteOperationDescriptorArguments = ArgumentList(SeparatedList( new[] { Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(attributeData[nameof(WebInvokeAttribute.Method)].ToString()))), Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(uriTemplate.ToString()))), Argument(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ParseTypeName(nameof(OperationWebMessageFormat)), IdentifierName(Enum.GetName(typeof(OperationWebMessageFormat), requestFormat)))), Argument(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ParseTypeName(nameof(OperationWebMessageFormat)), IdentifierName(Enum.GetName(typeof(OperationWebMessageFormat), responseFormat)))), } )); var descriptorInitializer = EqualsValueClause(InvocationExpression(ObjectCreationExpression(ParseTypeName(nameof(RemoteOperationDescriptor))), remoteOperationDescriptorArguments)); var descriptorInitialization = LocalDeclarationStatement(VariableDeclaration(ParseTypeName("var")) .AddVariables(descriptorDeclaration.WithInitializer(descriptorInitializer))); return(descriptorInitialization); }
private static VariableDeclaratorSyntax GetNewDeclarator( VariableDeclaratorSyntax declarator, TypeSyntax type, ITypeSymbol typeSymbol) { ExpressionSyntax value = typeSymbol.GetDefaultValueSyntax(type); EqualsValueClauseSyntax initializer = declarator.Initializer; EqualsValueClauseSyntax newInitializer = EqualsValueClause(value); if (initializer == null || initializer.IsMissing) { return(declarator .WithIdentifier(declarator.Identifier.WithoutTrailingTrivia()) .WithInitializer(newInitializer.WithTrailingTrivia(declarator.Identifier.TrailingTrivia))); } else { return(declarator .WithInitializer(newInitializer.WithTriviaFrom(initializer.EqualsToken))); } }
protected FieldDeclarationSyntax ResolveStaticGlobal(ITypeInfo type, string name, ExpressionSyntax?initializer = null, bool @private = true) { VariableDeclaratorSyntax declarator = VariableDeclarator ( identifier: Identifier(name) ); if (initializer is not null) { declarator = declarator.WithInitializer ( initializer: EqualsValueClause ( initializer ) ); } return(FieldDeclaration ( declaration: VariableDeclaration ( type: ResolveType(type), variables: SingletonSeparatedList(declarator) ) ) .WithModifiers ( TokenList ( new SyntaxToken[] { Token(@private ? SyntaxKind.PrivateKeyword : SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword), Token(SyntaxKind.ReadOnlyKeyword) } ) )); }
public static Task <Document> RefactorAsync( Document document, LocalDeclarationStatementSyntax localDeclaration, VariableDeclaratorSyntax declarator, ITypeSymbol typeSymbol, CancellationToken cancellationToken = default) { VariableDeclaratorSyntax newDeclarator = GetNewDeclarator(localDeclaration.Declaration.Type.WithoutTrivia()); LocalDeclarationStatementSyntax newNode = localDeclaration.ReplaceNode(declarator, newDeclarator); if (localDeclaration.SemicolonToken.IsMissing && localDeclaration.Declaration.Variables.Last().Equals(declarator)) { newNode = newNode.WithSemicolonToken(SemicolonToken().WithTrailingTrivia(newDeclarator.GetTrailingTrivia())); } return(document.ReplaceNodeAsync(localDeclaration, newNode, cancellationToken)); VariableDeclaratorSyntax GetNewDeclarator(TypeSyntax type) { ExpressionSyntax value = typeSymbol.GetDefaultValueSyntax(document.GetDefaultSyntaxOptions(), type); EqualsValueClauseSyntax initializer = declarator.Initializer; EqualsValueClauseSyntax newInitializer = EqualsValueClause(value); if (initializer?.IsMissing != false) { return(declarator .WithIdentifier(declarator.Identifier.WithoutTrailingTrivia()) .WithInitializer(newInitializer.WithTrailingTrivia(declarator.Identifier.TrailingTrivia))); } else { return(declarator .WithInitializer(newInitializer.WithTriviaFrom(initializer.EqualsToken))); } } }
private static Task <Document> RefactorAsync( Document document, SingleLocalDeclarationStatementInfo localInfo, TypeSyntax type, CancellationToken cancellationToken) { LocalDeclarationStatementSyntax localStatement = localInfo.Statement; StatementsInfo statementsInfo = SyntaxInfo.StatementsInfo(localStatement); int index = statementsInfo.IndexOf(localStatement); VariableDeclaratorSyntax declarator = localInfo.Declarator; VariableDeclaratorSyntax newDeclarator = declarator.WithInitializer(null); VariableDeclarationSyntax newDeclaration = localInfo.Declaration.ReplaceNode(declarator, newDeclarator); if (type != null) { newDeclaration = newDeclaration.WithType(type.WithTriviaFrom(newDeclaration.Type)); } LocalDeclarationStatementSyntax newLocalStatement = localStatement .WithDeclaration(newDeclaration) .WithTrailingTrivia(NewLine()) .WithFormatterAnnotation(); ExpressionStatementSyntax assignmentStatement = SimpleAssignmentStatement(IdentifierName(localInfo.Identifier), localInfo.Initializer.Value) .WithTrailingTrivia(localStatement.GetTrailingTrivia()) .WithFormatterAnnotation(); StatementsInfo newStatementsInfo = statementsInfo .Insert(index + 1, assignmentStatement) .ReplaceAt(index, newLocalStatement); return(document.ReplaceStatementsAsync(statementsInfo, newStatementsInfo, cancellationToken)); }
/// <summary> /// Normalizes the <paramref name="declaration" />. /// </summary> public override SyntaxNode VisitVariableDeclarator(VariableDeclaratorSyntax declaration) { var objectCreation = declaration?.Initializer?.Value as ObjectCreationExpressionSyntax; if (objectCreation == null) return declaration; var symbol = SemanticModel.GetDeclaredSymbol(declaration); if (symbol == null) return declaration; ITypeSymbol type; string name; switch (symbol.Kind) { case SymbolKind.Field: var fieldSymbol = ((IFieldSymbol)symbol); type = fieldSymbol.Type; name = fieldSymbol.Name; break; case SymbolKind.Local: var localSymbol = ((ILocalSymbol)symbol); type = localSymbol.Type; name = localSymbol.Name; break; default: return declaration; } var fault = SemanticModel.GetTypeSymbol<Fault>(); if (!type.Equals(fault) && !type.IsDerivedFrom(fault)) return declaration; return declaration.WithInitializer(declaration.Initializer.WithValue(AddNameInitializer(fault, objectCreation, name))); }
public static Task <Document> RefactorAsync(Document document, IfAnalysis ifAnalysis, CancellationToken cancellationToken = default) { switch (ifAnalysis.Kind) { case IfAnalysisKind.IfElseToAssignmentWithCoalesceExpression: { return(IfElseToAssignmentWithCoalesceExpressionAsync(document, (IfElseToAssignmentWithCoalesceExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToAssignmentWithConditionalExpression: { return(IfElseToAssignmentWithConditionalExpressionAsync(document, (IfElseToAssignmentWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.AssignmentAndIfToAssignmentWithConditionalExpression: { var analysis = (AssignmentAndIfToAssignmentWithConditionalExpressionAnalysis)ifAnalysis; ConditionalExpressionSyntax conditionalExpression = CreateConditionalExpression(analysis.IfStatement.Condition, analysis.WhenTrue, analysis.WhenFalse); ExpressionStatementSyntax newStatement = analysis.Statement.ReplaceNode(analysis.Right, conditionalExpression); return(ToAssignmentWithConditionalExpressionAsync(document, analysis, newStatement, cancellationToken)); } case IfAnalysisKind.LocalDeclarationAndIfElseAssignmentWithConditionalExpression: { var analysis = (LocalDeclarationAndIfElseToAssignmentWithConditionalExpressionAnalysis)ifAnalysis; ConditionalExpressionSyntax conditionalExpression = CreateConditionalExpression(analysis.IfStatement.Condition, analysis.WhenTrue, analysis.WhenFalse); VariableDeclaratorSyntax declarator = analysis.Statement.Declaration.Variables[0]; EqualsValueClauseSyntax initializer = declarator.Initializer; EqualsValueClauseSyntax newInitializer = (initializer != null) ? initializer.WithValue(conditionalExpression) : EqualsValueClause(conditionalExpression); LocalDeclarationStatementSyntax newStatement = analysis.Statement.ReplaceNode(declarator, declarator.WithInitializer(newInitializer)); return(ToAssignmentWithConditionalExpressionAsync(document, analysis, newStatement, cancellationToken)); } case IfAnalysisKind.IfElseToAssignmentWithExpression: { return(IfElseToAssignmentWithExpressionAsync(document, (IfElseToAssignmentWithExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToAssignmentWithCondition: { return(IfElseToAssignmentWithConditionAsync(document, (IfElseToAssignmentWithConditionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToReturnWithCoalesceExpression: case IfAnalysisKind.IfElseToYieldReturnWithCoalesceExpression: case IfAnalysisKind.IfReturnToReturnWithCoalesceExpression: { return(IfToReturnWithCoalesceExpressionAsync(document, (IfToReturnWithCoalesceExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToReturnWithConditionalExpression: { return(IfElseToReturnWithConditionalExpressionAsync(document, (IfElseToReturnWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToReturnWithBooleanExpression: { return(IfElseToReturnWithBooleanExpressionAsync(document, (IfElseToReturnWithBooleanExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToReturnWithExpression: case IfAnalysisKind.IfElseToYieldReturnWithExpression: case IfAnalysisKind.IfReturnToReturnWithExpression: { return(IfToReturnWithExpressionAsync(document, (IfToReturnWithExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToYieldReturnWithConditionalExpression: { return(IfElseToYieldReturnWithConditionalExpressionAsync(document, (IfElseToYieldReturnWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToYieldReturnWithBooleanExpression: { return(IfElseToYieldReturnWithBooleanExpressionAsync(document, (IfElseToYieldReturnWithBooleanExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfReturnToReturnWithConditionalExpression: { return(IfReturnToReturnWithConditionalExpressionAsync(document, (IfReturnToReturnWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfReturnToReturnWithBooleanExpression: { return(IfReturnToReturnWithBooleanExpressionAsync(document, (IfReturnToReturnWithBooleanExpressionAnalysis)ifAnalysis, cancellationToken)); } default: { throw new InvalidOperationException(); } } }
public static void ReplaceMember(DocumentEditor editor, SemanticModel model, VariableDeclaratorSyntax original, InvocationExpressionSyntax avaloniaInvocation) { var parent = (VariableDeclarationSyntax)original.Parent; if (parent.Variables.Count > 1) { editor.ReplaceNode(original.Initializer.Value, avaloniaInvocation); } else { var replacedParent = parent .WithType((TypeSyntax)editor.Generator.TypeExpression(model.GetSpeculativeTypeInfo(original.SpanStart, avaloniaInvocation, SpeculativeBindingOption.BindAsExpression).Type)) .WithVariables(parent.Variables.Replace(parent.Variables[0], original.WithInitializer(original.Initializer.WithValue(avaloniaInvocation)))); var fieldDeclaration = parent.Parent as FieldDeclarationSyntax; editor.ReplaceNode(fieldDeclaration, fieldDeclaration.WithDeclaration(replacedParent)); } }
public static async Task <Document> RefactorAsync( Document document, VariableDeclaratorSyntax declarator, CancellationToken cancellationToken) { var declaration = (VariableDeclarationSyntax)declarator.Parent; var localDeclaration = (LocalDeclarationStatementSyntax)declaration.Parent; StatementContainer container; if (StatementContainer.TryCreate(localDeclaration, out container)) { SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(localDeclaration); StatementSyntax nextStatement = statements[index + 1]; var expressionStatement = (ExpressionStatementSyntax)nextStatement; var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression; ExpressionSyntax right = assignment.Right; EqualsValueClauseSyntax initializer = declarator.Initializer; ExpressionSyntax value = initializer?.Value; VariableDeclaratorSyntax newDeclarator = (value != null) ? declarator.ReplaceNode(value, right) : declarator.WithInitializer(EqualsValueClause(right)); LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration.ReplaceNode(declarator, newDeclarator); SyntaxTriviaList trailingTrivia = nextStatement.GetTrailingTrivia(); IEnumerable <SyntaxTrivia> trivia = container .Node .DescendantTrivia(TextSpan.FromBounds(localDeclaration.Span.End, right.SpanStart)); if (!trivia.All(f => f.IsWhitespaceOrEndOfLineTrivia())) { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trivia.Concat(trailingTrivia)); } else { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trailingTrivia); } SyntaxList <StatementSyntax> newStatements = statements .Replace(localDeclaration, newLocalDeclaration) .RemoveAt(index + 1); return(await document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken).ConfigureAwait(false)); } Debug.Assert(false, ""); return(document); }