public static void ReplaceCallToAsync([NotNull] IInvocationExpression invocationExpression, [NotNull] CSharpElementFactory factory, bool useAsync) { var returnType = invocationExpression.Type(); var referenceExpression = invocationExpression.FirstChild as IReferenceExpression; if (referenceExpression?.NameIdentifier == null) { return; } var newMethodName = GenerateAsyncMethodName(referenceExpression.NameIdentifier.Name); var newReferenceExpression = referenceExpression.QualifierExpression == null ? factory.CreateReferenceExpression("$0", newMethodName) : factory.CreateReferenceExpression("$0.$1", referenceExpression.QualifierExpression, newMethodName); newReferenceExpression.SetTypeArgumentList(referenceExpression.TypeArgumentList); var callFormat = useAsync ? "await $0($1).ConfigureAwait(false)" : returnType.IsVoid() ? "$0($1).Wait()" : "$0($1).Result"; var awaitExpression = factory.CreateExpression(callFormat, newReferenceExpression, invocationExpression.ArgumentList); invocationExpression.ReplaceBy(awaitExpression); }
protected override IForStatement CreateStatement(CSharpElementFactory factory, ICSharpExpression expression) { var hasLength = (LengthName != null); var template = hasLength ? "for(var x=$0;x>=0;x--)" : "for(var x=$0;x>0;x--)"; var forStatement = (IForStatement) factory.CreateStatement( template + EmbeddedStatementBracesTemplate, expression); var variable = (ILocalVariableDeclaration) forStatement.Initializer.Declaration.Declarators[0]; var initializer = (IExpressionInitializer) variable.Initial; if (!hasLength) { var value = initializer.Value.ReplaceBy(expression); value.ReplaceBy(value); } else { var lengthAccess = factory.CreateReferenceExpression("expr.$0", LengthName); lengthAccess = initializer.Value.ReplaceBy(lengthAccess); lengthAccess.QualifierExpression.NotNull().ReplaceBy(expression); lengthAccess.ReplaceBy(factory.CreateExpression("$0 - 1", lengthAccess)); } return forStatement; }
private void ConvertArrayCreationWithoutInitializer(CSharpElementFactory factory) { var currentCreation = myArrayCreationExpression; var firstSize = currentCreation.Sizes[0].NotNull("currentCreation.Sizes[0] != null").CopyWithResolve(); var secondSize = currentCreation.Sizes[1].NotNull("currentCreation.Sizes[1] != null").CopyWithResolve(); IArrayCreationExpression newCreation; if (currentCreation.TypeUsage == null) { newCreation = factory.CreateExpression("new [$0][]", currentCreation.Sizes[0]) as IArrayCreationExpression; } else { newCreation = factory.CreateExpression("new $0[$1][]", currentCreation.TypeUsage, currentCreation.Sizes[0]) as IArrayCreationExpression; } Assertion.Assert(newCreation != null, "newCreation != null"); newCreation = currentCreation.ReplaceBy(newCreation); if (myVariableDeclaration is ILocalVariableDeclaration) { var statement = newCreation.GetContainingStatement().NotNull("statement != null"); var forInitializer = factory.CreateStatement( "for (int index = 0; index < $0; index++) {$1[index] = new $2[$3];}", firstSize, factory.CreateReferenceExpression(myVariableDeclaration.DeclaredName), myType.ElementType, secondSize); StatementUtil.InsertStatement(forInitializer, ref statement, false); } }
protected override IForStatement CreateStatement(CSharpElementFactory factory, ICSharpExpression expression) { var hasLength = (LengthName != null); var template = hasLength ? "for(var x=$0;x>=0;x--)" : "for(var x=$0;x>0;x--)"; var forStatement = (IForStatement)factory.CreateStatement( template + EmbeddedStatementBracesTemplate, expression); var variable = (ILocalVariableDeclaration)forStatement.Initializer.Declaration.Declarators[0]; var initializer = (IExpressionInitializer)variable.Initial; if (!hasLength) { var value = initializer.Value.ReplaceBy(expression); value.ReplaceBy(value); } else { var lengthAccess = factory.CreateReferenceExpression("expr.$0", LengthName); lengthAccess = initializer.Value.ReplaceBy(lengthAccess); lengthAccess.QualifierExpression.NotNull().ReplaceBy(expression); lengthAccess.ReplaceBy(factory.CreateExpression("$0 - 1", lengthAccess)); } return(forStatement); }
protected override ICSharpExpression CreateReplacementExpression(ICSharpExpression expression, IDeclaredElement declaredElement) { CSharpElementFactory factory = CSharpElementFactory.GetInstance(expression); return(factory.CreateReferenceExpression("$0.$1", ((IReferenceExpression)expression).QualifierExpression, declaredElement.ShortName)); }
public static void RenameOldUsages([NotNull] ICSharpExpression originExpression, [CanBeNull] IDeclaredElement localVariableDeclaredElement, [NotNull] string newName, [NotNull] CSharpElementFactory factory) { originExpression.GetPsiServices().Locks.AssertReadAccessAllowed(); var statement = ExpressionStatementNavigator.GetByExpression(originExpression); if (statement != null) { statement.RemoveOrReplaceByEmptyStatement(); } else { if (localVariableDeclaredElement == null) { originExpression.ReplaceBy(factory.CreateReferenceExpression(newName)); } else if (!newName.Equals(localVariableDeclaredElement.ShortName)) { var provider = DefaultUsagesProvider.Instance; var usages = provider.GetUsages(localVariableDeclaredElement, originExpression.GetContainingNode <IMethodDeclaration>().NotNull("scope != null")); originExpression.GetContainingStatement().NotNull("expression.GetContainingStatement() != null") .RemoveOrReplaceByEmptyStatement(); foreach (var usage in usages) { if (usage.IsValid() && usage is IReferenceExpression node) { node.ReplaceBy(factory.CreateReferenceExpression(newName)); } } } else { DeclarationStatementNavigator.GetByVariableDeclaration( LocalVariableDeclarationNavigator.GetByInitial( ExpressionInitializerNavigator.GetByValue( originExpression.GetContainingParenthesizedExpression()))) ?.RemoveOrReplaceByEmptyStatement(); } } }
public override MethodInvocation ProcessUsage(IReference reference) { var referenceExpression = reference.GetTreeNode() as IReferenceExpression; if (referenceExpression == null) { Driver.AddConflict(ReferenceConflict.CreateError(reference, "{0} can not be updated correctly.", "Usage")); return(null); } bool isExtensionMethod = referenceExpression.IsExtensionMethod(); IInvocationExpression invocation = InvocationExpressionNavigator.GetByInvokedExpression(referenceExpression); if (invocation == null) { Driver.AddConflict(ReferenceConflict.CreateError(reference, "{0} can not be updated correctly.", "Usage")); return(null); } ITreeNode element = GetArgument(invocation, isExtensionMethod); var argument = element as ICSharpArgument; IType type = argument != null?GetTypeOfValue(argument.Value) : GetTypeOfValue(element); if (type == null || !type.CanUseExplicitly(invocation)) { Driver.AddConflict(ReferenceConflict.CreateError( reference, "Argument of {0} is not valid 'typeof' expression.", "usage")); return(null); } // we can rely on resolve result since method declaration is not yet changed. ResolveResultWithInfo resolveResult = reference.Resolve(); ISubstitution substitution = resolveResult.Result.Substitution; var method = resolveResult.DeclaredElement as IMethod; if (method == null) { return(null); } if (argument != null) { invocation.RemoveArgument(argument); return(new MethodInvocation(reference, type, method, substitution)); } CSharpElementFactory factory = CSharpElementFactory.GetInstance(invocation.GetPsiModule()); IReferenceExpression newInvokedExpression = invocation.InvokedExpression.ReplaceBy(factory.CreateReferenceExpression("$0", Executer.Method)); return(new MethodInvocation(newInvokedExpression.Reference, type, method, substitution)); }
private ICSharpExpression GetMappingTypeName(IType scalarType) { var columnTypeNameClass = provider.GetType($"SKBKontur.Billy.Core.Common.Quering.ColumnTypeNames"); var columnTypeNameClassType = columnTypeNameClass.GetTypeElement(); // ReSharper disable once InconsistentNaming ICSharpExpression createExpression(string x) => columnTypeNameClassType != null ? factory.CreateReferenceExpression("$0.$1", columnTypeNameClassType.ShortName, x) : factory.CreateExpression($"ColumnTypeNames.{x}"); if (scalarType.IsNullable()) { scalarType = scalarType.GetNullableUnderlyingType(); } if (scalarType.IsInt() || scalarType.IsEnumType()) { return(createExpression(Constants.Int)); } if (scalarType.IsGuid()) { return(createExpression(Constants.UniqueIdentifier)); } if (scalarType.IsString()) { return(createExpression(Constants.NVarChar)); } if (scalarType.IsBool()) { return(createExpression(Constants.Bit)); } if (scalarType.IsDateTime()) { return(createExpression(Constants.DateTime2)); } if (scalarType.IsLong()) { return(createExpression(Constants.BigInt)); } if (scalarType.IsDecimal()) { return(createExpression(Constants.Decimal)); } return(factory.CreateExpression("TODO")); }
protected override void PlaceExpression( IForStatement forStatement, ICSharpExpression expression, CSharpElementFactory factory) { var condition = (IRelationalExpression) forStatement.Condition; if (LengthPropertyName == null) { condition.RightOperand.ReplaceBy(expression); } else { var lengthAccess = factory.CreateReferenceExpression("expr.$0", LengthPropertyName); lengthAccess = condition.RightOperand.ReplaceBy(lengthAccess); lengthAccess.QualifierExpression.NotNull().ReplaceBy(expression); } }
protected override void PlaceExpression( IForStatement forStatement, ICSharpExpression expression, CSharpElementFactory factory) { var variable = (ILocalVariableDeclaration)forStatement.Initializer.Declaration.Declarators[0]; var initializer = (IExpressionInitializer)variable.Initial; if (LengthPropertyName == null) { var value = initializer.Value.ReplaceBy(expression); value.ReplaceBy(factory.CreateExpression("$0 - 1", value)); } else { var lengthAccess = factory.CreateReferenceExpression("expr.$0", LengthPropertyName); lengthAccess = initializer.Value.ReplaceBy(lengthAccess); lengthAccess.QualifierExpression.NotNull().ReplaceBy(expression); lengthAccess.ReplaceBy(factory.CreateExpression("$0 - 1", lengthAccess)); } }
protected override IForStatement CreateStatement(CSharpElementFactory factory, ICSharpExpression expression) { var template = "for(var x=0;x<$0;x++)" + EmbeddedStatementBracesTemplate; var forStatement = (IForStatement)factory.CreateStatement(template, expression); var condition = (IRelationalExpression)forStatement.Condition; if (LengthName == null) { condition.RightOperand.ReplaceBy(expression); } else { var lengthAccess = factory.CreateReferenceExpression("expr.$0", LengthName); lengthAccess = condition.RightOperand.ReplaceBy(lengthAccess); lengthAccess.QualifierExpression.NotNull().ReplaceBy(expression); } return(forStatement); }
protected override IForStatement CreateStatement(CSharpElementFactory factory, ICSharpExpression expression) { var template = "for(var x=0;x<$0;x++)" + EmbeddedStatementBracesTemplate; var forStatement = (IForStatement) factory.CreateStatement(template, expression); var condition = (IRelationalExpression) forStatement.Condition; if (LengthName == null) { condition.RightOperand.ReplaceBy(expression); } else { var lengthAccess = factory.CreateReferenceExpression("expr.$0", LengthName); lengthAccess = condition.RightOperand.ReplaceBy(lengthAccess); lengthAccess.QualifierExpression.NotNull().ReplaceBy(expression); } return forStatement; }