private MethodDeclarationSyntax GetGetInstanceMethod(string className) { var comment = GetDocCommentWithText("Get new element instance"); var md = SF.MethodDeclaration( SF.IdentifierName(className), SF.Identifier("GetInstance") ) .AddModifiers(SF.Token(SyntaxKind.PublicKeyword).WithLeadingTrivia(SF.Trivia(comment)), SF.Token(SyntaxKind.StaticKeyword)) .AddParameterListParameters( SF.Parameter(SF.Identifier("parentElement")) .WithType(SF.IdentifierName(nameof(CombinedWebElementInfo))) ) .WithExpressionBody( SF.ArrowExpressionClause( SF.ObjectCreationExpression(SF.IdentifierName(className)) .WithInitializer( SF.InitializerExpression( SyntaxKind.ObjectInitializerExpression ) .AddExpressions( SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(nameof(WebElementInfo.Parent)), SF.IdentifierName("parentElement")) ) ) ) ) .WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)); return(md); }
public override SyntaxList <StatementSyntax> VisitAssignmentStatement(VBSyntax.AssignmentStatementSyntax node) { var lhs = (ExpressionSyntax)node.Left.Accept(_nodesVisitor); var lOperation = _semanticModel.GetOperation(node.Left); //Already dealt with by call to the same method in VisitInvocationExpression if (CommonConversions.GetParameterizedPropertyAccessMethod(lOperation, out var _) != null) { return(SingleStatement(lhs)); } var rhs = (ExpressionSyntax)node.Right.Accept(_nodesVisitor); if (node.Left is VBSyntax.IdentifierNameSyntax id && _methodNode is VBSyntax.MethodBlockSyntax mb && HasReturnVariable && id.Identifier.ValueText.Equals(mb.SubOrFunctionStatement.Identifier.ValueText, StringComparison.OrdinalIgnoreCase)) { lhs = ReturnVariable; } if (node.IsKind(VBasic.SyntaxKind.ExponentiateAssignmentStatement)) { rhs = SyntaxFactory.InvocationExpression( SyntaxFactory.ParseExpression($"{nameof(Math)}.{nameof(Math.Pow)}"), ExpressionSyntaxExtensions.CreateArgList(lhs, rhs)); } var kind = node.Kind().ConvertToken(TokenContext.Local); var assignment = SyntaxFactory.AssignmentExpression(kind, lhs, rhs); var postAssignment = GetPostAssignmentStatements(node); return(postAssignment.Insert(0, SyntaxFactory.ExpressionStatement(assignment))); }
StatementSyntax GenerateAssignForTempVariable() { return(SF.ExpressionStatement(SF.AssignmentExpression( kind: SyntaxKind.SimpleAssignmentExpression, left: Basics.SimpleMemberAccess(Basics.TryParseOutVariableIdentifier, MemberDecl), right: SF.IdentifierName(_variadleIdentifier)))); }
public static ConstructorDeclarationSyntax MakeConstructor(string className, IEnumerable <Field> fields) { var constructorParameters = SF.ParameterList( SF.SeparatedList( fields.Select(field => SF.Parameter(SF.Identifier(field.Name)) .WithType(field.Type)))); var constructorBodyStatements = fields.Select( field => SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.ThisExpression(), SF.IdentifierName(field.Name) ), SF.IdentifierName(field.Name)))); return (SF.ConstructorDeclaration(className) .WithModifiers(SF.TokenList(new[] { SF.Token(SyntaxKind.PublicKeyword) })) .WithParameterList(constructorParameters) .WithBody(SF.Block(constructorBodyStatements))); }
private static ExpressionStatementSyntax[] GetMissingAssignmentExpressions( ParameterSyntax[] updatedParamters, IEnumerable <MemberDeclarationSyntax> injectablesMissingAnAssignment) { return(injectablesMissingAnAssignment.Select(injectable => { var injectableTypeIdentifier = injectable.GetMemberType(); var injectableType = injectableTypeIdentifier.GetTypeName(); var injectableName = injectable.GetMemberIdentifier().Text; var correspondingParameter = updatedParamters .SingleOrDefault(parameter => { var paramType = parameter.Type.GetTypeName(); return paramType == injectableType; }); if (correspondingParameter == null) { return null; } var paramName = correspondingParameter.Identifier.Text; return SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(injectableName), SF.IdentifierName(paramName))); }) .Where(x => x != null) .ToArray()); }
public override SyntaxList <StatementSyntax> VisitAddRemoveHandlerStatement(VBSyntax.AddRemoveHandlerStatementSyntax node) { var syntaxKind = node.Kind() == VBasic.SyntaxKind.AddHandlerStatement ? SyntaxKind.AddAssignmentExpression : SyntaxKind.SubtractAssignmentExpression; return(SingleStatement(SyntaxFactory.AssignmentExpression(syntaxKind, (ExpressionSyntax)node.EventExpression.Accept(nodesVisitor), (ExpressionSyntax)node.DelegateExpression.Accept(nodesVisitor)))); }
public override SyntaxList <StatementSyntax> VisitAddRemoveHandlerStatement(VBSyntax.AddRemoveHandlerStatementSyntax node) { var syntaxKind = ConvertAddRemoveHandlerToCSharpSyntaxKind(node); return(SingleStatement(SyntaxFactory.AssignmentExpression(syntaxKind, (ExpressionSyntax)node.EventExpression.Accept(_nodesVisitor), (ExpressionSyntax)node.DelegateExpression.Accept(_nodesVisitor)))); }
private MemberDeclarationSyntax ExplicitInterfaceMember() { var decoratedValueTypeSyntax = ValueTypeSyntax; if (Symbol.ReturnsByRef) { decoratedValueTypeSyntax = F.RefType(decoratedValueTypeSyntax); } else if (Symbol.ReturnsByRefReadonly) { decoratedValueTypeSyntax = F.RefType(decoratedValueTypeSyntax).WithReadOnlyKeyword(F.Token(SyntaxKind.ReadOnlyKeyword)); } var mockedProperty = F.PropertyDeclaration(decoratedValueTypeSyntax, Symbol.Name) .WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol))); if (Symbol.IsReadOnly) { ExpressionSyntax elementAccess = F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MemberMockName), F.IdentifierName("Value")); if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly) { elementAccess = TypesForSymbols.WrapByRef(elementAccess, ValueTypeSyntax); } mockedProperty = mockedProperty.WithExpressionBody(F.ArrowExpressionClause(elementAccess)) .WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)); } else { if (!Symbol.IsWriteOnly) { mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithExpressionBody(F.ArrowExpressionClause(F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MemberMockName), F.IdentifierName("Value")))) .WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)) ); } if (!Symbol.IsReadOnly) { mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithExpressionBody( F.ArrowExpressionClause( F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MemberMockName), F.IdentifierName("Value")), F.IdentifierName("value")))) .WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)) ); } } return(mockedProperty); }
/// <summary> /// Yields "variable = false;" /// </summary> /// <param name="variable"></param> /// <returns></returns> internal static ExpressionStatementSyntax AssignFalse(string variable) { return (SF.ExpressionStatement( SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.ParseExpression(variable), SF.ParseExpression($"false") ) )); }
/// <summary> /// Yields "variable = lhs==rhs;" /// </summary> /// <param name="variable"></param> /// <param name="value"></param> /// <returns></returns> internal static ExpressionStatementSyntax AssignValueEqualsValue(string variable, string lhs, string rhs) { return (SF.ExpressionStatement( SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.ParseExpression(variable), SF.ParseExpression($"{lhs}=={rhs}") ) )); }
/// <summary> /// Yields "variable = value==0;" /// </summary> /// <param name="variable"></param> /// <param name="value"></param> /// <returns></returns> internal static ExpressionStatementSyntax AssignValueEqualsZero(string variable, string value) { return (SF.ExpressionStatement( SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.ParseExpression(variable), SF.ParseExpression($"{value}==0") ) )); }
public override void Exit() { var setStatement = SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, VariableHelper.MakeStateVariableExpression(_variableName), _valueExpression ) ); _exitHandler(setStatement); }
public static StatementSyntax MakeModelAssignmentStatement() { return(SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.BaseExpression(), SF.IdentifierName("Model") ), SF.IdentifierName("model") ))); }
public override SyntaxList <StatementSyntax> VisitEraseStatement(VBSyntax.EraseStatementSyntax node) { var eraseStatements = node.Expressions.Select <VBSyntax.ExpressionSyntax, StatementSyntax>(arrayExpression => { var lhs = arrayExpression.Accept(_nodesVisitor); var rhs = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression); var assignmentExpressionSyntax = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, (ExpressionSyntax)lhs, rhs); return(SyntaxFactory.ExpressionStatement(assignmentExpressionSyntax)); }); return(SyntaxFactory.List(eraseStatements)); }
public override void Exit() { ExpressionSyntax expression = CreateMethodCall(_methodName, _requiresState, _arguments, _hookName); if (_asVariable != null) { expression = SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, VariableHelper.MakeStateVariableExpression(_asVariable), expression ); } _exitHandler(expression); }
private async Task <Document> AddSecureFlags(Document document, Diagnostic diagnostic, CancellationToken cancellationToken, string[] propertyNames) { var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var variableDeclarator = FindParentNode(root.FindToken(diagnostic.Location.SourceSpan.Start).Parent); if (variableDeclarator == null) { return(document); //Abort! } if (!(variableDeclarator.Parent is VariableDeclarationSyntax variableDeclaration)) { return(document); //Abort! } if (!(variableDeclaration.Parent is LocalDeclarationStatementSyntax parentDeclaration)) { return(document); //Abort! } var identifierCookie = variableDeclaration.Variables[0]; //Building the nodes model var nodes = new List <SyntaxNode>(); foreach (var property in propertyNames) { var newAssignment = SF.ExpressionStatement( SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName(identifierCookie.Identifier), SF.IdentifierName(property)), SF.LiteralExpression(SyntaxKind.TrueLiteralExpression) )) .WithLeadingTrivia(CodeFixUtil.KeepLastLine(parentDeclaration.GetLeadingTrivia())); /* * .WithLeadingTrivia(parentDeclaration.GetLeadingTrivia() * .Insert(0, SF.ElasticEndOfLine(Environment.NewLine)) * );*/ nodes.Add(newAssignment); } //Inserting the nodes var newRoot = root.InsertNodesAfter(parentDeclaration, nodes); return(document.WithSyntaxRoot(newRoot)); }
protected ExpressionStatementSyntax InitialisationStatement(TypeSyntax mockPropertyType) { return(F.ExpressionStatement(F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, F.IdentifierName(MemberMockName), F.ObjectCreationExpression(mockPropertyType) .WithExpressionsAsArgumentList( F.ThisExpression(), F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(ClassSymbol.Name)), F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(InterfaceSymbol.Name)), F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(Symbol.Name)), F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(MemberMockName)), StrictnessExpression() )))); }
public override BlockSyntax GenerateMethodBody() { var whileStatement = new SyntaxList <StatementSyntax>() .Add(SF.ParseStatement("if (!reader.TryGetByte(out var bsonType)) { return false; }")) .Add(SF.ParseStatement("if (!reader.TryGetCStringAsSpan(out var bsonName)) { return false; } ")) .AddRange(OperationsList.CreateReadOperations(ClassSymbol, Members).Generate()) .Add(SF.ParseStatement(@$ "throw new ArgumentException($" "{ClassSymbol.Name}.TryParse with bson type number {{bsonType}} and name {{System.Text.Encoding.UTF8.GetString(bsonName)}}" ");")); return(SF.Block( SF.ExpressionStatement(SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, Basics.TryParseOutVariableIdentifier, Basics.ObjectCreationWitoutArgs(ClassSymbol))), SF.ParseStatement("if (!reader.TryGetInt32(out var docLength)) { return false; }"), SF.ParseStatement("var unreaded = reader.Remaining + sizeof(int);"), SF.WhileStatement( attributeLists: default,
public override SyntaxList <StatementSyntax> VisitAssignmentStatement(VBSyntax.AssignmentStatementSyntax node) { var lhs = (ExpressionSyntax)node.Left.Accept(_nodesVisitor); var rhs = (ExpressionSyntax)node.Right.Accept(_nodesVisitor); if (node.IsKind(VBasic.SyntaxKind.ExponentiateAssignmentStatement)) { rhs = SyntaxFactory.InvocationExpression( SyntaxFactory.ParseExpression($"{nameof(Math)}.{nameof(Math.Pow)}"), ExpressionSyntaxExtensions.CreateArgList(lhs, rhs)); } var kind = node.Kind().ConvertToken(TokenContext.Local); return(SingleStatement(SyntaxFactory.AssignmentExpression(kind, lhs, rhs))); }
private ExpressionStatementSyntax CreateNewArrayAssignment(VBSyntax.ExpressionSyntax vbArrayExpression, ExpressionSyntax csArrayExpression, List <ExpressionSyntax> convertedBounds, int nodeSpanStart) { var arrayRankSpecifierSyntax = SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SeparatedList(convertedBounds)); var convertedType = (IArrayTypeSymbol)_semanticModel.GetTypeInfo(vbArrayExpression).ConvertedType; var typeSyntax = GetTypeSyntaxFromTypeSymbol(convertedType.ElementType, nodeSpanStart); var arrayCreation = SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(typeSyntax, SyntaxFactory.SingletonList(arrayRankSpecifierSyntax))); var assignmentExpressionSyntax = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, csArrayExpression, arrayCreation); var newArrayAssignment = SyntaxFactory.ExpressionStatement(assignmentExpressionSyntax); return(newArrayAssignment); }
protected virtual IfStatementSyntax GenerateIfBsonTypeNull() { return(SF.IfStatement( condition: SF.BinaryExpression( SyntaxKind.EqualsExpression, Basics.TryParseBsonTypeIdentifier, SF.Token(SyntaxKind.EqualsEqualsToken), Basics.NumberLiteral(10) ), statement: SF.Block( SF.ExpressionStatement( SF.AssignmentExpression( kind: SyntaxKind.SimpleAssignmentExpression, left: Basics.SimpleMemberAccess(Basics.TryParseOutVariableIdentifier, Basics.IdentifierName(MemberDecl.DeclSymbol)), right: SF.LiteralExpression(SyntaxKind.DefaultLiteralExpression)) ), SF.ContinueStatement()) )); }
private static AssignmentExpressionSyntax MakeAssignment(IPropertySymbol property, ParameterSyntax parameter) { ExpressionSyntax propertyAccessor = SF.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SF.IdentifierName(parameter.ToString()), SF.IdentifierName(property.Name)); // In case of ICollection<>, or a type implementing ICollection<T>, append .ToList() bool IsCollection(INamedTypeSymbol t) => t.Name == nameof(ICollection) && t.TypeParameters.Length == 1; if (property.Type is INamedTypeSymbol type && (IsCollection(type) || type.AllInterfaces.Any(IsCollection))) { propertyAccessor = SF.InvocationExpression(SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, propertyAccessor, SF.IdentifierName("ToList"))); } return(SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(property.Name), propertyAccessor)); // Thing = x.Thing(.ToList()) }
private static ConstructorDeclarationSyntax MakeConstructor( TypeDeclarationSyntax type, IEnumerable <Field> fields, ConstructorDeclarationSyntax maybePreviousConstructor) { var fieldsList = fields.ToList(); var constructorParameters = SF.ParameterList( SF.SeparatedList( fieldsList.Select( field => SF.Parameter(SF.Identifier(field.Name)) .WithType(field.Type) .WithAttributeLists(field.Attributes) ) ) ); var constructorBodyStatements = fieldsList.Select( field => SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.ThisExpression(), SF.IdentifierName(field.Name) ), SF.IdentifierName(field.Name) ) ) ); var previousAttributes = maybePreviousConstructor?.AttributeLists ?? new SyntaxList <AttributeListSyntax>(); var res = SF.ConstructorDeclaration(type.Identifier.Text) .WithAttributeLists(previousAttributes) .WithModifiers(SF.TokenList(new[] { SF.Token(SyntaxKind.PublicKeyword) })) .WithParameterList(constructorParameters) .WithBody(SF.Block(constructorBodyStatements)); res = fieldsList.Any(x => x.StructuredTrivia != null) ? res.WithLeadingTrivia( MakeXmlDocComments(maybePreviousConstructor, fieldsList, Constants.DefaultCtorSummary) ) : maybePreviousConstructor?.HasLeadingTrivia ?? false? res.WithLeadingTrivia(maybePreviousConstructor.GetLeadingTrivia()) : res; return(res); }
private ClassDeclarationSyntax AddConstructor(INamedTypeSymbol interfaceType, ClassDeclarationSyntax classDclr, SimpleStubsConfig config) { string ctorName = NamingUtils.GetStubName(interfaceType.Name); string defaultMockBehavior = GetValidMockBehaviorEnumValue(config.DefaultMockBehavior); var ctorParameter = SF.Parameter(SF.Identifier("mockBehavior")) .WithType(SF.ParseTypeName("MockBehavior")) .WithDefault(SF.EqualsValueClause(SF.ParseExpression($"MockBehavior.{defaultMockBehavior}"))); classDclr = classDclr.AddMembers(SF.ConstructorDeclaration(ctorName) .WithModifiers(SF.TokenList(SF.Token(SyntaxKind.PublicKeyword))) .WithParameterList(SF.ParameterList().AddParameters(ctorParameter)) .WithBody(SF.Block().AddStatements(SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName("MockBehavior"), SF.IdentifierName("mockBehavior"))) ))); return(classDclr); }
/// <summary> /// Returns syntax for setting the value of this field. /// </summary> /// <param name="instance">The instance of the containing type.</param> /// <param name="value">Syntax for the new value.</param> /// <returns>Syntax for setting the value of this field.</returns> public ExpressionSyntax GetSetter(ExpressionSyntax instance, ExpressionSyntax value) { // If the field is the backing field for an accessible auto-property use the property directly. if (this.PropertyInfo != null && this.PropertyInfo.GetSetMethod() != null && !this.IsObsolete) { return SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, instance.Member(this.PropertyInfo.Name), value); } var instanceArg = SF.Argument(instance); if (this.FieldInfo.DeclaringType != null && this.FieldInfo.DeclaringType.IsValueType) { instanceArg = instanceArg.WithRefOrOutKeyword(SF.Token(SyntaxKind.RefKeyword)); } return SF.InvocationExpression(SF.IdentifierName(this.SetterFieldName)) .AddArgumentListArguments(instanceArg, SF.Argument(value)); }
public override void Exit() { List <StatementSyntax> loopStatements = new List <StatementSyntax>(); //loopStatements.Add(StateHelper.MakeStatePushStatement()); loopStatements.Add(SF.ExpressionStatement( SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, VariableHelper.MakeStateVariableExpression(_asVariableName), SF.IdentifierName(_iteratorVariableName) ) ) ); if (_hookName != null) { loopStatements.Add(BlockContext.MakeWriteStatement(MethodCallContext.CreateMethodCall(_hookName, true))); } //loopStatements.Add(StateHelper.MakeStatePopWriteStatement()); var forEachStatement = SF.ForEachStatement(SF.ParseTypeName("var"), _iteratorVariableName, _expression, SF.Block(loopStatements)); _exitHandler(forEachStatement); }
public override SyntaxList <StatementSyntax> VisitAssignmentStatement(VBSyntax.AssignmentStatementSyntax node) { var lhs = (ExpressionSyntax)node.Left.Accept(_nodesVisitor); var rhs = (ExpressionSyntax)node.Right.Accept(_nodesVisitor); if (node.Left is VBSyntax.IdentifierNameSyntax id && _methodNode is VBSyntax.MethodBlockSyntax mb && HasReturnVariable && id.Identifier.ValueText.Equals(mb.SubOrFunctionStatement.Identifier.ValueText, StringComparison.OrdinalIgnoreCase)) { lhs = ReturnVariable; } if (node.IsKind(VBasic.SyntaxKind.ExponentiateAssignmentStatement)) { rhs = SyntaxFactory.InvocationExpression( SyntaxFactory.ParseExpression($"{nameof(Math)}.{nameof(Math.Pow)}"), ExpressionSyntaxExtensions.CreateArgList(lhs, rhs)); } var kind = node.Kind().ConvertToken(TokenContext.Local); return(SingleStatement(SyntaxFactory.AssignmentExpression(kind, lhs, rhs))); }
public ExpressionSyntax GetSetter(ExpressionSyntax instance, ExpressionSyntax value, ExpressionSyntax boxedInstance = null) { Expression <Action> fieldSetter = () => this.FieldInfo.SetValue(default(object), default(object)); // If the field is the backing field for an auto-property, try to use the property directly. var propertyName = Regex.Match(this.FieldInfo.Name, "^<([^>]+)>.*$"); if (propertyName.Success && this.FieldInfo.DeclaringType != null) { var name = propertyName.Groups[1].Value; var property = this.FieldInfo.DeclaringType.GetProperty(name, BindingFlags.Instance | BindingFlags.Public); if (property != null && property.GetSetMethod() != null) { return(SF.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, instance.Member(property.Name), value)); } } return(fieldSetter.Invoke(this.FieldInfoExpression) .AddArgumentListArguments(SF.Argument(boxedInstance ?? instance), SF.Argument(value))); }
public override SyntaxList <StatementSyntax> VisitAssignmentStatement(VBSyntax.AssignmentStatementSyntax node) { var lhs = (ExpressionSyntax)node.Left.Accept(_nodesVisitor); var rhs = (ExpressionSyntax)node.Right.Accept(_nodesVisitor); // e.g. VB DivideAssignmentExpression "/=" is always on doubles unless you use the "\=" IntegerDivideAssignmentExpression, so need to cast in C# // Need the unconverted type, since the whole point is that it gets converted to a double by the operator if (node.IsKind(VBasic.SyntaxKind.DivideAssignmentStatement) && !node.HasOperandOfUnconvertedType("System.Double", _semanticModel)) { var doubleType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.DoubleKeyword)); rhs = SyntaxFactory.CastExpression(doubleType, rhs); } if (node.IsKind(VBasic.SyntaxKind.ExponentiateAssignmentStatement)) { rhs = SyntaxFactory.InvocationExpression( SyntaxFactory.ParseExpression($"{nameof(Math)}.{nameof(Math.Pow)}"), ExpressionSyntaxExtensions.CreateArgList(lhs, rhs)); } var kind = node.Kind().ConvertToken(TokenContext.Local); return(SingleStatement(SyntaxFactory.AssignmentExpression(kind, lhs, rhs))); }
protected MemberDeclarationSyntax ExplicitInterfaceMember() { var baseReturnType = Symbol.ReturnsVoid ? F.PredefinedType(F.Token(SyntaxKind.VoidKeyword)) : TypesForSymbols.ParseTypeName(Symbol.ReturnType, Symbol.ReturnTypeIsNullableOrOblivious()); var returnType = baseReturnType; if (Symbol.ReturnsByRef) { returnType = F.RefType(returnType); } else if (Symbol.ReturnsByRefReadonly) { returnType = F.RefType(returnType).WithReadOnlyKeyword(F.Token(SyntaxKind.ReadOnlyKeyword)); } var mockedMethod = ExplicitInterfaceMemberMethodDeclaration(returnType); var memberMockInstance = ExplicitInterfaceMemberMemberMockInstance(); ExpressionSyntax invocation = F.InvocationExpression( F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, memberMockInstance, F.IdentifierName("Call"))) .WithExpressionsAsArgumentList(ParametersType.BuildArgumentListWithOriginalNames()); // look at the return parameters. If we don't have any we can just make the call. // if we only have one and that's the return value, we can just return it. if (ReturnValuesType.Count == 0 || ReturnValuesType.Count == 1 && ReturnValuesType[0].IsReturnValue) { if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly) { invocation = TypesForSymbols.WrapByRef(invocation, baseReturnType); } mockedMethod = mockedMethod.WithExpressionBody(F.ArrowExpressionClause(invocation)) .WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)); } // if we only have one and that's not a return value, we can just assign it to the out or ref parameter it corresponds to. else if (ReturnValuesType.Count == 1) { mockedMethod = mockedMethod.WithBody(F.Block(F.ExpressionStatement(F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, F.IdentifierName(ReturnValuesType[0].OriginalName), invocation)))); } else { // if we have more than one, put it in a temporary variable. (consider name clashes with method parameter names) var x = new Uniquifier(Symbol.Parameters.Select(m => m.Name)); string tmp = x.GetUniqueName("tmp"); var statements = new List <StatementSyntax> { F.LocalDeclarationStatement(F.VariableDeclaration(F.IdentifierName("var")).WithVariables( F.SingletonSeparatedList(F.VariableDeclarator(F.Identifier(tmp)).WithInitializer(F.EqualsValueClause(invocation))))) }; // then for any out or ref parameters, set their values from the temporary variable. foreach (var rv in ReturnValuesType.Where(a => !a.IsReturnValue)) { statements.Add(F.ExpressionStatement(F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, F.IdentifierName(rv.OriginalName), F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(tmp), F.IdentifierName(rv.TupleSafeName))))); } // finally, if there is a 'proper' return type, return the corresponding value from the temporary variable. foreach (var rv in ReturnValuesType.Where(a => a.IsReturnValue)) { ExpressionSyntax memberAccess = F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(tmp), F.IdentifierName(rv.TupleSafeName)); if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly) { memberAccess = TypesForSymbols.WrapByRef(memberAccess, baseReturnType); } statements.Add(F.ReturnStatement(memberAccess)); } mockedMethod = mockedMethod.WithBody(F.Block(statements)); } return(mockedMethod); }