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);
}