/// <summary> /// Returns syntax for dispatching <paramref name="event"/> to <paramref name="actor"/>. /// </summary> /// <param name="event"> /// The event. /// </param> /// <param name="actor"> /// The actor description. /// </param> /// <returns> /// Syntax for dispatching <paramref name="event"/> to <paramref name="actor"/>. /// </returns> private static StatementSyntax GenerateActorBlock( ExpressionSyntax @event, ActorDescription actor) { var @var = SF.IdentifierName("var"); var grainType = actor.Type.GetTypeSyntax(); var getGrain = SF.InvocationExpression(SF.IdentifierName("GrainFactory").Member("GetGrain", grainType)) .AddArgumentListArguments(SF.Argument(@event.Member("To").Member("Id"))); var grain = SF.VariableDeclarator("grain").WithInitializer(SF.EqualsValueClause(getGrain)); var grainDeclaration = SF.LocalDeclarationStatement(SF.VariableDeclaration(@var).AddVariables(grain)); var returnNull = SF.ReturnStatement(SF.LiteralExpression(SyntaxKind.NullLiteralExpression)); var defaultSection = SF.SwitchSection().AddLabels(SF.DefaultSwitchLabel()).AddStatements(returnNull); var methodSwitch = SF.SwitchStatement(@event.Member("Type")) .AddSections( actor.Methods.Values.Where(_ => _.Visible) .Select(method => GetMethodSwitchCase(@event, method)) .ToArray()) .AddSections(defaultSection); var methodDispatcher = SF.Block().AddStatements(grainDeclaration, methodSwitch); return(methodDispatcher); }
private async Task <EqualsValueClauseSyntax> ConvertEqualsValueClauseSyntax( VariableDeclaratorSyntax vbDeclarator, ModifiedIdentifierSyntax vbName, VBSyntax.ExpressionSyntax vbInitValue, ITypeSymbol declaredSymbolType, ISymbol declaredSymbol, CSharpSyntaxNode initializerOrMethodDecl) { var csTypeSyntax = GetTypeSyntax(declaredSymbolType); bool isField = vbDeclarator.Parent.IsKind(SyntaxKind.FieldDeclaration); bool isConst = declaredSymbol is IFieldSymbol fieldSymbol && fieldSymbol.IsConst || declaredSymbol is ILocalSymbol localSymbol && localSymbol.IsConst; EqualsValueClauseSyntax equalsValueClauseSyntax; if (await GetInitializerFromNameAndType(declaredSymbolType, vbName, initializerOrMethodDecl) is ExpressionSyntax adjustedInitializerExpr) { var convertedInitializer = vbInitValue != null ? TypeConversionAnalyzer.AddExplicitConversion(vbInitValue, adjustedInitializerExpr, isConst : isConst) : adjustedInitializerExpr; equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(convertedInitializer); } else if (isField || declaredSymbol != null && _semanticModel.IsDefinitelyAssignedBeforeRead(declaredSymbol, vbName)) { equalsValueClauseSyntax = null; } else { // VB initializes variables to their default equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(csTypeSyntax)); } return(equalsValueClauseSyntax); }
private ClassDeclarationSyntax GetClassForConstLocatorInInfo(WebLocatorInfo locatorInfo) { var infoMembers = new List <MemberDeclarationSyntax>(); var infoMembersList = new List <(string type, string fName, ExpressionSyntax expr)> { (nameof(WebLocatorType), nameof(locatorInfo.LocatorType), GetESForValue(locatorInfo.LocatorType)), ("string", nameof(locatorInfo.LocatorValue), GetESForValue(locatorInfo.LocatorValue)), ("bool", nameof(locatorInfo.IsRelative), GetESForValue(locatorInfo.IsRelative)) }; foreach (var infoMemberItem in infoMembersList) { var fd = SF.FieldDeclaration( SF.VariableDeclaration(SF.ParseTypeName(infoMemberItem.type)) .AddVariables(SF.VariableDeclarator(SF.Identifier(infoMemberItem.fName)) .WithInitializer(SF.EqualsValueClause(infoMemberItem.expr)) ) ) .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.ConstKeyword)); infoMembers.Add(fd); } var infoCD = SF.ClassDeclaration(LocatorStaticClassName) .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)) .AddMembers(infoMembers.ToArray()); return(infoCD); }
/* * public static T Or<T>(this Option<T> thisOption, T or) * { * T v; * * thisOption. * * return v; * } */ public static FieldDeclarationSyntax Field(string fieldName, string type, Optional <ExpressionSyntax> assignment, params SyntaxKind[] modifiers) { //var st = SF.ParseStatement( $"static public readonly {m_class.Identifier} def = new {m_class.Identifier};" ); //var newClass = SF.ParseExpression( $"new {m_class.Identifier}()" ); var declarator = SF.VariableDeclarator(fieldName); if (assignment.HasValue) { declarator = declarator.WithInitializer(SF.EqualsValueClause(assignment.Value)); } var decl = SF.VariableDeclaration(SF.IdentifierName(type), SF.SingletonSeparatedList(declarator)); var field = SF.FieldDeclaration(decl); if (modifiers.Length > 0) { var stl = new SyntaxTokenList(modifiers.Select(mod => SF.Token(mod))); field = field.WithModifiers(stl); } return(field); }
private static MethodDeclarationSyntax MakeWithMethod( TypeDeclarationSyntax type, IEnumerable <Field> fields, MethodDeclarationSyntax maybePreviousWithMethod) { var fieldsList = fields.ToList(); var withMethodParameters = SF.ParameterList( SF.SeparatedList( fieldsList.Select( field => SF.Parameter(SF.Identifier(field.Name)) .WithType(field.IsNonNullable ? SF.NullableType(field.Type) : field.Type) .WithDefault( SF.EqualsValueClause( SF.Token(SyntaxKind.EqualsToken), SF.LiteralExpression(SyntaxKind.NullLiteralExpression) ) ) .WithAttributeLists(field.Attributes) ) ) ); var withMethodBodyStatements = fieldsList.Select( field => SF.Argument( SF.BinaryExpression( SyntaxKind.CoalesceExpression, SF.IdentifierName(field.Name), SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.ThisExpression(), SF.IdentifierName(field.Name) ) ) ) ); var previousAttributes = maybePreviousWithMethod?.AttributeLists ?? new SyntaxList <AttributeListSyntax>(); var typeSyntax = TypeSyntaxFactory.GetTypeSyntax( type.Identifier.Text, type.TypeParameterList?.Parameters.Select(x => x.Identifier.Text).ToArray() ); var res = SF.MethodDeclaration(typeSyntax, "With") .WithAttributeLists(previousAttributes) .WithModifiers(SF.TokenList(new[] { SF.Token(SyntaxKind.PublicKeyword) })) .WithParameterList(withMethodParameters) .WithBody( SF.Block( SF.ReturnStatement( SF.ObjectCreationExpression( typeSyntax, SF.ArgumentList(SF.SeparatedList(withMethodBodyStatements)), null ) ) ) ); res = fieldsList.Any(x => x.StructuredTrivia != null) ? res.WithLeadingTrivia( MakeXmlDocComments(maybePreviousWithMethod, fieldsList, Constants.DefaultModifierSummary) ) : maybePreviousWithMethod?.HasLeadingTrivia ?? false? res.WithLeadingTrivia(maybePreviousWithMethod.GetLeadingTrivia()) : res; return(res); }
private MemberDeclarationSyntax TypedMockProviderField() { return(F.FieldDeclaration(F.VariableDeclaration(TypesForSymbols.TypedMockProvider()).WithVariables( F.SingletonSeparatedList(F.VariableDeclarator(F.Identifier(MockProviderName)) .WithInitializer(F.EqualsValueClause(F.ObjectCreationExpression(TypesForSymbols.TypedMockProvider()) .WithArgumentList(F.ArgumentList()))))) ).WithModifiers(F.TokenList(F.Token(SyntaxKind.PrivateKeyword), F.Token(SyntaxKind.ReadOnlyKeyword)))); }
/// <summary> /// Returns syntax for the deserializer method. /// </summary> /// <param name="type">The type.</param> /// <param name="fields">The fields.</param> /// <returns>Syntax for the deserializer method.</returns> private static MemberDeclarationSyntax GenerateDeserializerMethod(Type type, List <FieldInfoMember> fields) { Expression <Action> deserializeInner = () => SerializationManager.DeserializeInner(default(Type), default(IDeserializationContext)); var contextParameter = SF.IdentifierName("context"); var resultDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(type.GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("result") .WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type))))); var resultVariable = SF.IdentifierName("result"); var body = new List <StatementSyntax> { resultDeclaration }; // Value types cannot be referenced, only copied, so there is no need to box & record instances of value types. if (!type.GetTypeInfo().IsValueType) { // Record the result for cyclic deserialization. Expression <Action <IDeserializationContext> > recordObject = ctx => ctx.RecordObject(default(object)); var currentSerializationContext = contextParameter; body.Add( SF.ExpressionStatement( recordObject.Invoke(currentSerializationContext) .AddArgumentListArguments(SF.Argument(resultVariable)))); } // Deserialize all fields. foreach (var field in fields) { var deserialized = deserializeInner.Invoke() .AddArgumentListArguments( SF.Argument(SF.TypeOfExpression(field.Type)), SF.Argument(contextParameter)); body.Add( SF.ExpressionStatement( field.GetSetter( resultVariable, SF.CastExpression(field.Type, deserialized)))); } body.Add(SF.ReturnStatement(SF.CastExpression(type.GetTypeSyntax(), resultVariable))); return (SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "Deserializer") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)) .AddParameterListParameters( SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()), SF.Parameter(SF.Identifier("context")).WithType(typeof(IDeserializationContext).GetTypeSyntax())) .AddBodyStatements(body.ToArray()) .AddAttributeLists( SF.AttributeList() .AddAttributes(SF.Attribute(typeof(DeserializerMethodAttribute).GetNameSyntax())))); }
public FieldDeclarationSyntax ToFieldDeclaration() { if (canonicalName.value != name.name.value) { Console.WriteLine($"Warning!!! '{canonicalName.value}' != '{name.name.value}';"); } if (annotations.Count != 0) { Console.WriteLine($"Warning!!! Annotations!;"); } var declaratorSyntax = SF.VariableDeclarator(SF.Identifier(name.name.value)); if (initializer.TryGetValue(out var initializerExpression)) { declaratorSyntax = declaratorSyntax.WithInitializer( // todo: I think this might not work ... a lot! SF.EqualsValueClause(initializerExpression.ToLiteralExpressionSyntax())); } var fieldDeclaration = SF.FieldDeclaration( SF.VariableDeclaration(type.ToTypeSyntax()) .WithVariables(SF.SingletonSeparatedList <VariableDeclaratorSyntax>(declaratorSyntax))); if (flags.HasFlag(Flag.isConst)) { fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.ConstKeyword))); } if (flags.HasFlag(Flag.isFinal)) { fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.ReadOnlyKeyword))); } if (flags.HasFlag(Flag.isStatic)) { fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.StaticKeyword))); } if (flags.HasFlag(Flag.isCovariant)) { throw new NotImplementedException(); } if (flags.HasFlag(Flag.isGenericCovariantImpl)) { throw new NotImplementedException(); } if (flags.HasFlag(Flag.hasImplicitSetter)) { throw new NotImplementedException(); } if (flags.HasFlag(Flag.hasImplicitGetter)) { throw new NotImplementedException(); } return(fieldDeclaration); }
private static MemberDeclarationSyntax GenerateDeserializerMethod(Type type, List <FieldInfoMember> fields) { Expression <Action> deserializeInner = () => SerializationManager.DeserializeInner(default(Type), default(BinaryTokenStreamReader)); var streamParameter = SF.IdentifierName("stream"); var resultDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(type.GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("result") .WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type))))); var resultVariable = SF.IdentifierName("result"); var boxedResultVariable = resultVariable; var body = new List <StatementSyntax> { resultDeclaration }; if (type.IsValueType) { // For value types, we need to box the result for reflection-based setters to work. body.Add(SF.LocalDeclarationStatement( SF.VariableDeclaration(typeof(object).GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("boxedResult").WithInitializer(SF.EqualsValueClause(resultVariable))))); boxedResultVariable = SF.IdentifierName("boxedResult"); } // Deserialize all fields. foreach (var field in fields) { var deserialized = deserializeInner.Invoke() .AddArgumentListArguments( SF.Argument(SF.TypeOfExpression(field.Type)), SF.Argument(streamParameter)); body.Add( SF.ExpressionStatement( field.GetSetter( resultVariable, SF.CastExpression(field.Type, deserialized), boxedResultVariable))); } body.Add(SF.ReturnStatement(SF.CastExpression(type.GetTypeSyntax(), boxedResultVariable))); return (SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "Deserializer") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)) .AddParameterListParameters( SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()), SF.Parameter(SF.Identifier("stream")).WithType(typeof(BinaryTokenStreamReader).GetTypeSyntax())) .AddBodyStatements(body.ToArray()) .AddAttributeLists( SF.AttributeList() .AddAttributes(SF.Attribute(typeof(DeserializerMethodAttribute).GetNameSyntax())))); }
private SyntaxTree CreateSyntaxTree() { var compilationUnit = SF .CompilationUnit() .AddUsings ( SF.UsingDirective (SF.ParseName("System")) ); var ns = SF .NamespaceDeclaration(SF.IdentifierName("SynTreeFred")); var cls = SF .ClassDeclaration("Henry") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword)); // How to define base class and interfaces, with/without generics // //cls = cls.AddBaseListTypes( // SF.SimpleBaseType(SF.ParseTypeName("Object")), // SF.SimpleBaseType(SF.ParseTypeName("IEnumerable<string>"))); var inti = SF .VariableDeclaration(SF.ParseTypeName("int")) .AddVariables ( SF.VariableDeclarator ( SF.Identifier("i"), null, SF.EqualsValueClause ( SF.LiteralExpression ( SyntaxKind.NumericLiteralExpression, SF.Literal(12) ) ) ) ); var field = SF.FieldDeclaration(inti) .AddModifiers(SF.Token(SyntaxKind.PrivateKeyword)); var syntax = SF.ParseStatement("return ++i;"); var methodDeclaration = SF .MethodDeclaration(SF.ParseTypeName("int"), "GetNextInt") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword)) .WithBody(SF.Block(syntax)); cls = cls.AddMembers(field, methodDeclaration); ns = ns.AddMembers(cls); compilationUnit = compilationUnit.AddMembers(ns); return(compilationUnit.SyntaxTree); }
public Dictionary <string, VariableDeclarationSyntax> SplitVariableDeclarations( VariableDeclaratorSyntax declarator, bool preferExplicitType = false) { var rawType = ConvertDeclaratorType(declarator, preferExplicitType); var initializer = ConvertInitializer(declarator); var newDecls = new Dictionary <string, VariableDeclarationSyntax>(); var method = declarator.Ancestors().OfType <MethodBlockBaseSyntax>().SingleOrDefault(); DataFlowAnalysis dataFlow = null; if (method != null) { dataFlow = _semanticModel.AnalyzeDataFlow(method.Statements.First(), method.Statements.Last()); } foreach (var name in declarator.Names) { var(type, adjustedInitializer) = AdjustFromName(rawType, name, initializer); bool isField = declarator.Parent.IsKind(SyntaxKind.FieldDeclaration); EqualsValueClauseSyntax equalsValueClauseSyntax; if (adjustedInitializer != null) { equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(adjustedInitializer); } else { Func <ISymbol, bool> equalsId = s => s.Name.Equals(name.Identifier.ValueText, StringComparison.OrdinalIgnoreCase); bool alwaysAssigned = dataFlow != null && dataFlow.AlwaysAssigned.Any(equalsId); bool neverRead = dataFlow != null && !dataFlow.ReadInside.Any(equalsId) && !dataFlow.ReadOutside.Any(equalsId); if (isField || alwaysAssigned || neverRead) { equalsValueClauseSyntax = null; } else { equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(type)); } } var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax); string k = type.ToString(); if (newDecls.TryGetValue(k, out var decl)) { newDecls[k] = decl.AddVariables(v); } else { newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v)); } } return(newDecls); }
private static VariableDeclarationSyntax CreateVariableDeclaration(string variableName, ExpressionSyntax variableValue) { var variableDeclaratorSyntax = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(variableName), null, SyntaxFactory.EqualsValueClause(variableValue)); var declaration = SyntaxFactory.VariableDeclaration( SyntaxFactory.IdentifierName("var"), SyntaxFactory.SingletonSeparatedList(variableDeclaratorSyntax)); return(declaration); }
private async Task <EqualsValueClauseSyntax> ConvertEqualsValueClauseSyntaxAsync( VariableDeclaratorSyntax vbDeclarator, VBSyntax.ModifiedIdentifierSyntax vbName, VBSyntax.ExpressionSyntax vbInitValue, ITypeSymbol declaredSymbolType, ISymbol declaredSymbol, CSharpSyntaxNode initializerOrMethodDecl) { var csTypeSyntax = GetTypeSyntax(declaredSymbolType); bool isField = vbDeclarator.Parent.IsKind(SyntaxKind.FieldDeclaration); bool declaredConst = declaredSymbol is IFieldSymbol fieldSymbol && fieldSymbol.IsConst || declaredSymbol is ILocalSymbol localSymbol && localSymbol.IsConst; EqualsValueClauseSyntax equalsValueClauseSyntax; if (await GetInitializerFromNameAndTypeAsync(declaredSymbolType, vbName, initializerOrMethodDecl) is ExpressionSyntax adjustedInitializerExpr) { var convertedInitializer = vbInitValue != null ? TypeConversionAnalyzer.AddExplicitConversion(vbInitValue, adjustedInitializerExpr, isConst : declaredConst) : adjustedInitializerExpr; if (isField && !declaredSymbol.IsStatic && !_semanticModel.IsDefinitelyStatic(vbName, vbInitValue)) { if (_typeContext.Initializers.ShouldAddTypeWideInitToThisPart) { var lhs = SyntaxFactory.IdentifierName(ConvertIdentifier(vbName.Identifier, sourceTriviaMapKind: SourceTriviaMapKind.None)); _typeContext.Initializers.AdditionalInstanceInitializers.Add((lhs, CSSyntaxKind.SimpleAssignmentExpression, adjustedInitializerExpr)); equalsValueClauseSyntax = null; } else { var returnBlock = SyntaxFactory.Block(SyntaxFactory.ReturnStatement(adjustedInitializerExpr)); _typeContext.HoistedState.Hoist <HoistedParameterlessFunction>(new HoistedParameterlessFunction(GetInitialValueFunctionName(vbName), csTypeSyntax, returnBlock)); equalsValueClauseSyntax = null; } } else { equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(convertedInitializer); } } else if (isField || declaredSymbol != null && _semanticModel.IsDefinitelyAssignedBeforeRead(declaredSymbol, vbName)) { equalsValueClauseSyntax = null; } else { // VB initializes variables to their default equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(csTypeSyntax)); } return(equalsValueClauseSyntax); }
private static ClassDeclarationSyntax AddStubContainerField(ClassDeclarationSyntax classDclr, string stubName) { classDclr = classDclr.AddMembers( SF.FieldDeclaration( SF.VariableDeclaration(SF.ParseTypeName($"StubContainer<{stubName}>"), SF.SeparatedList(new[] { SF.VariableDeclarator(SF.Identifier("_stubs"), null, SF.EqualsValueClause(SF.ParseExpression($"new StubContainer<{stubName}>()"))) }))) .AddModifiers(SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); return(classDclr); }
/// <summary> /// Yields "bool name;" /// </summary> /// <param name="name"></param> /// <returns></returns> internal static LocalDeclarationStatementSyntax DeclareIntVariable(string name) { return (SF.LocalDeclarationStatement( SF.VariableDeclaration( SF.PredefinedType(SF.Token(SyntaxKind.IntKeyword)), new SeparatedSyntaxList <VariableDeclaratorSyntax>().Add( SF.VariableDeclarator(SF.Identifier(name), default(BracketedArgumentListSyntax), SF.EqualsValueClause(SF.ParseExpression("0"))) ) ) )); }
public Dictionary <string, VariableDeclarationSyntax> SplitVariableDeclarations( VariableDeclaratorSyntax declarator, bool preferExplicitType = false) { var rawType = ConvertDeclaratorType(declarator, preferExplicitType); var initializer = ConvertInitializer(declarator); var newDecls = new Dictionary <string, VariableDeclarationSyntax>(); foreach (var name in declarator.Names) { var(type, adjustedInitializer) = AdjustFromName(rawType, name, initializer); bool isField = declarator.Parent.IsKind(SyntaxKind.FieldDeclaration); EqualsValueClauseSyntax equalsValueClauseSyntax; if (adjustedInitializer != null) { var vbInitializer = declarator.Initializer?.Value; // Explicit conversions are never needed for AsClause, since the type is inferred from the RHS var convertedInitializer = vbInitializer == null ? adjustedInitializer : TypeConversionAnalyzer.AddExplicitConversion(vbInitializer, adjustedInitializer); equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(convertedInitializer); } else if (isField || _semanticModel.IsDefinitelyAssignedBeforeRead(declarator, name)) { equalsValueClauseSyntax = null; } else { // VB initializes variables to their default equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(type)); } var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax); string k = type.ToString(); if (newDecls.TryGetValue(k, out var decl)) { newDecls[k] = decl.AddVariables(v); } else { newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v)); } } return(newDecls); }
private static MemberDeclarationSyntax GenerateSerializerMethod(Type type, List <FieldInfoMember> fields) { Expression <Action> serializeInner = () => SerializationManager.SerializeInner(default(object), default(ISerializationContext), default(Type)); var contextParameter = SF.IdentifierName("context"); var body = new List <StatementSyntax> { SF.LocalDeclarationStatement( SF.VariableDeclaration(type.GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("input") .WithInitializer( SF.EqualsValueClause( SF.CastExpression(type.GetTypeSyntax(), SF.IdentifierName("untypedInput")))))) }; var inputExpression = SF.IdentifierName("input"); // Serialize all members. foreach (var field in fields) { body.Add( SF.ExpressionStatement( serializeInner.Invoke() .AddArgumentListArguments( SF.Argument(field.GetGetter(inputExpression, forceAvoidCopy: true)), SF.Argument(contextParameter), SF.Argument(SF.TypeOfExpression(field.FieldInfo.FieldType.GetTypeSyntax()))))); } return (SF.MethodDeclaration(typeof(void).GetTypeSyntax(), "Serializer") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)) .AddParameterListParameters( SF.Parameter(SF.Identifier("untypedInput")).WithType(typeof(object).GetTypeSyntax()), SF.Parameter(SF.Identifier("context")).WithType(typeof(ISerializationContext).GetTypeSyntax()), SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax())) .AddBodyStatements(body.ToArray()) .AddAttributeLists( SF.AttributeList() .AddAttributes(SF.Attribute(typeof(SerializerMethodAttribute).GetNameSyntax())))); }
public override SyntaxList <StatementSyntax> VisitWithBlock(VBSyntax.WithBlockSyntax node) { var withExpression = (ExpressionSyntax)node.WithStatement.Expression.Accept(nodesVisitor); withBlockTempVariableNames.Push(GetUniqueVariableNameInScope(node, "withBlock")); try { var variableDeclaratorSyntax = SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier(withBlockTempVariableNames.Peek()), null, SyntaxFactory.EqualsValueClause(withExpression)); var declaration = SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration( SyntaxFactory.IdentifierName("var"), SyntaxFactory.SingletonSeparatedList(variableDeclaratorSyntax))); var statements = node.Statements.SelectMany(s => s.Accept(this)); return(SingleStatement(SyntaxFactory.Block(new[] { declaration }.Concat(statements).ToArray()))); } finally { withBlockTempVariableNames.Pop(); } }
public static MethodDeclarationSyntax MakeWithMethod(string className, IEnumerable <Field> fields) { var withMethodParameters = SF.ParameterList( SF.SeparatedList( fields.Select( field => SF.Parameter(SF.Identifier(field.Name)) .WithType( field.IsNonNullable ? SF.NullableType(field.Type) : field.Type ) .WithDefault( SF.EqualsValueClause( SF.Token(SyntaxKind.EqualsToken), SF.LiteralExpression(SyntaxKind.NullLiteralExpression)))))); var withMethodBodyStatements = fields.Select( field => SF.Argument( SF.BinaryExpression( SyntaxKind.CoalesceExpression, SF.IdentifierName(field.Name), SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.ThisExpression(), SF.IdentifierName(field.Name))))); return (SF.MethodDeclaration( SF.ParseTypeName(className), "With" ) .WithModifiers(SF.TokenList(new[] { SF.Token(SyntaxKind.PublicKeyword) })) .WithParameterList(withMethodParameters) .WithBody( SF.Block( SF.ReturnStatement( SF.ObjectCreationExpression( SF.IdentifierName(className), SF.ArgumentList(SF.SeparatedList(withMethodBodyStatements)), null))))); }
public static PropertyDeclarationSyntax GenProperty(string type, string name, bool setter, string initializer = null) { var accessors = setter ? new[] { SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)), SF.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)) } : new[] { SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)) }; return(SF.PropertyDeclaration( attributeLists: SF.List <AttributeListSyntax>(), modifiers: SF.TokenList(SF.Token(SyntaxKind.PublicKeyword)), type: SF.ParseTypeName(type), explicitInterfaceSpecifier: null, identifier: SF.Identifier(name), accessorList: SF.AccessorList(SF.List(accessors)), expressionBody: null, initializer: initializer == null ? null : SF.EqualsValueClause(SF.ParseExpression(initializer)), semicolonToken: initializer == null ? SF.Token(SyntaxKind.None) : SF.Token(SyntaxKind.SemicolonToken))); }
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); }
private static MemberDeclarationSyntax[] GetFieldInfoFields(List <FieldInfoMember> fields) { var result = new List <MemberDeclarationSyntax>(); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed Expression <Action <Type> > getField = _ => _.GetField(string.Empty, BindingFlags.Default); // Expressions for specifying binding flags. var flags = SF.IdentifierName("System").Member("Reflection").Member("BindingFlags"); var publicFlag = flags.Member(BindingFlags.Public.ToString()); var nonPublicFlag = flags.Member(BindingFlags.NonPublic.ToString()); var instanceFlag = flags.Member(BindingFlags.Instance.ToString()); var bindingFlags = SF.ParenthesizedExpression( SF.BinaryExpression( SyntaxKind.BitwiseOrExpression, publicFlag, SF.BinaryExpression(SyntaxKind.BitwiseOrExpression, nonPublicFlag, instanceFlag))); // Add each field and initialize it. foreach (var field in fields) { var fieldInfo = getField.Invoke(SF.TypeOfExpression(field.FieldInfo.DeclaringType.GetTypeSyntax())) .AddArgumentListArguments( SF.Argument(field.FieldInfo.Name.GetLiteralExpression()), SF.Argument(bindingFlags)); var fieldInfoVariable = SF.VariableDeclarator(field.InfoFieldName).WithInitializer(SF.EqualsValueClause(fieldInfo)); result.Add( SF.FieldDeclaration( SF.VariableDeclaration(typeof(FieldInfo).GetTypeSyntax()).AddVariables(fieldInfoVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); } return(result.ToArray()); }
private SyntaxList <MemberDeclarationSyntax> CreateDefault() { var list = new SyntaxList <MemberDeclarationSyntax>(); //var st = SF.ParseStatement( $"static public readonly {m_class.Identifier} def = new {m_class.Identifier};" ); var newClass = SF.ParseExpression($"new {SU.ClassNameWithGenerics(m_class)}()"); var declarator = SF.VariableDeclarator("def") .WithInitializer(SF.EqualsValueClause(newClass)); var decl = SF.VariableDeclaration(SF.IdentifierName(SU.ClassNameWithGenerics(m_class)), SF.SingletonSeparatedList(declarator)); var keywords = SyntaxTokenList.Create(SF.Token(SyntaxKind.PublicKeyword)) .Add(SF.Token(SyntaxKind.StaticKeyword)) .Add(SF.Token(SyntaxKind.ReadOnlyKeyword)); var field = SF.FieldDeclaration(decl) .WithModifiers(keywords); list = list.Add(field); return(list); }
/// <summary> /// Generates a <see cref="GenericMethodInvoker"/> field for the provided generic method. /// </summary> /// <param name="method">The method.</param> /// <returns>The generated field.</returns> private static MemberDeclarationSyntax GenerateGenericInvokerField(MethodInfo method) { var fieldInfoVariable = SF.VariableDeclarator(GetGenericMethodInvokerFieldName(method)) .WithInitializer( SF.EqualsValueClause( SF.ObjectCreationExpression(typeof(GenericMethodInvoker).GetTypeSyntax()) .AddArgumentListArguments( SF.Argument(SF.TypeOfExpression(method.DeclaringType.GetTypeSyntax())), SF.Argument(method.Name.GetLiteralExpression()), SF.Argument( SF.LiteralExpression( SyntaxKind.NumericLiteralExpression, SF.Literal(method.GetGenericArguments().Length)))))); return (SF.FieldDeclaration( SF.VariableDeclaration(typeof(GenericMethodInvoker).GetTypeSyntax()).AddVariables(fieldInfoVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); }
/// <summary> /// Returns syntax for the static fields of the serializer class. /// </summary> /// <param name="fields">The fields.</param> /// <returns>Syntax for the static fields of the serializer class.</returns> private static MemberDeclarationSyntax[] GenerateStaticFields(List <FieldInfoMember> fields) { var result = new List <MemberDeclarationSyntax>(); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed Expression <Action <TypeInfo> > getField = _ => _.GetField(string.Empty, BindingFlags.Default); Expression <Action <Type> > getTypeInfo = _ => _.GetTypeInfo(); Expression <Action> getGetter = () => SerializationManager.GetGetter(default(FieldInfo)); Expression <Action> getReferenceSetter = () => SerializationManager.GetReferenceSetter(default(FieldInfo)); Expression <Action> getValueSetter = () => SerializationManager.GetValueSetter(default(FieldInfo)); // Expressions for specifying binding flags. var bindingFlags = SyntaxFactoryExtensions.GetBindingFlagsParenthesizedExpressionSyntax( SyntaxKind.BitwiseOrExpression, BindingFlags.Instance, BindingFlags.NonPublic, BindingFlags.Public); // Add each field and initialize it. foreach (var field in fields) { var fieldInfo = getField.Invoke(getTypeInfo.Invoke(SF.TypeOfExpression(field.FieldInfo.DeclaringType.GetTypeSyntax()))) .AddArgumentListArguments( SF.Argument(field.FieldInfo.Name.GetLiteralExpression()), SF.Argument(bindingFlags)); var fieldInfoVariable = SF.VariableDeclarator(field.InfoFieldName).WithInitializer(SF.EqualsValueClause(fieldInfo)); var fieldInfoField = SF.IdentifierName(field.InfoFieldName); if (!field.IsGettableProperty || !field.IsSettableProperty) { result.Add( SF.FieldDeclaration( SF.VariableDeclaration(typeof(FieldInfo).GetTypeSyntax()).AddVariables(fieldInfoVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); } // Declare the getter for this field. if (!field.IsGettableProperty) { var getterType = typeof(Func <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType) .GetTypeSyntax(); var fieldGetterVariable = SF.VariableDeclarator(field.GetterFieldName) .WithInitializer( SF.EqualsValueClause( SF.CastExpression( getterType, getGetter.Invoke().AddArgumentListArguments(SF.Argument(fieldInfoField))))); result.Add( SF.FieldDeclaration(SF.VariableDeclaration(getterType).AddVariables(fieldGetterVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); } if (!field.IsSettableProperty) { if (field.FieldInfo.DeclaringType != null && field.FieldInfo.DeclaringType.IsValueType) { var setterType = typeof(SerializationManager.ValueTypeSetter <,>).MakeGenericType( field.FieldInfo.DeclaringType, field.FieldInfo.FieldType).GetTypeSyntax(); var fieldSetterVariable = SF.VariableDeclarator(field.SetterFieldName) .WithInitializer( SF.EqualsValueClause( SF.CastExpression( setterType, getValueSetter.Invoke() .AddArgumentListArguments(SF.Argument(fieldInfoField))))); result.Add( SF.FieldDeclaration(SF.VariableDeclaration(setterType).AddVariables(fieldSetterVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); } else { var setterType = typeof(Action <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType) .GetTypeSyntax(); var fieldSetterVariable = SF.VariableDeclarator(field.SetterFieldName) .WithInitializer( SF.EqualsValueClause( SF.CastExpression( setterType, getReferenceSetter.Invoke() .AddArgumentListArguments(SF.Argument(fieldInfoField))))); result.Add( SF.FieldDeclaration(SF.VariableDeclaration(setterType).AddVariables(fieldSetterVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); } } } return(result.ToArray()); }
/// <summary> /// Returns syntax for the deep copier method. /// </summary> /// <param name="type">The type.</param> /// <param name="fields">The fields.</param> /// <returns>Syntax for the deep copier method.</returns> private static MemberDeclarationSyntax GenerateDeepCopierMethod(Type type, List <FieldInfoMember> fields) { var originalVariable = SF.IdentifierName("original"); var inputVariable = SF.IdentifierName("input"); var resultVariable = SF.IdentifierName("result"); var body = new List <StatementSyntax>(); if (type.GetCustomAttribute <ImmutableAttribute>() != null) { // Immutable types do not require copying. body.Add(SF.ReturnStatement(originalVariable)); } else { body.Add( SF.LocalDeclarationStatement( SF.VariableDeclaration(type.GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("input") .WithInitializer( SF.EqualsValueClause( SF.ParenthesizedExpression( SF.CastExpression(type.GetTypeSyntax(), originalVariable))))))); body.Add( SF.LocalDeclarationStatement( SF.VariableDeclaration(type.GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("result") .WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type)))))); // Copy all members from the input to the result. foreach (var field in fields) { body.Add(SF.ExpressionStatement(field.GetSetter(resultVariable, field.GetGetter(inputVariable)))); } // Record this serialization. Expression <Action> recordObject = () => SerializationContext.Current.RecordObject(default(object), default(object)); var currentSerializationContext = SyntaxFactory.AliasQualifiedName( SF.IdentifierName(SF.Token(SyntaxKind.GlobalKeyword)), SF.IdentifierName("Orleans")) .Qualify("Serialization") .Qualify("SerializationContext") .Qualify("Current"); body.Add( SF.ExpressionStatement( recordObject.Invoke(currentSerializationContext) .AddArgumentListArguments(SF.Argument(originalVariable), SF.Argument(resultVariable)))); body.Add(SF.ReturnStatement(resultVariable)); } return (SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "DeepCopier") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)) .AddParameterListParameters( SF.Parameter(SF.Identifier("original")).WithType(typeof(object).GetTypeSyntax())) .AddBodyStatements(body.ToArray()) .AddAttributeLists( SF.AttributeList().AddAttributes(SF.Attribute(typeof(CopierMethodAttribute).GetNameSyntax())))); }
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); }
public override SyntaxList <StatementSyntax> VisitForBlock(VBSyntax.ForBlockSyntax node) { var stmt = node.ForStatement; ExpressionSyntax startValue = (ExpressionSyntax)stmt.FromValue.Accept(_nodesVisitor); VariableDeclarationSyntax declaration = null; ExpressionSyntax id; if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax) { var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable; declaration = CommonConversions.SplitVariableDeclarations(v).Values.Single(); declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue)))); id = SyntaxFactory.IdentifierName(declaration.Variables[0].Identifier); } else { id = (ExpressionSyntax)stmt.ControlVariable.Accept(_nodesVisitor); var symbol = _semanticModel.GetSymbolInfo(stmt.ControlVariable).Symbol; if (symbol != null && !_semanticModel.LookupSymbols(node.FullSpan.Start, name: symbol.Name).Any()) { declaration = CommonConversions.CreateVariableDeclarationAndAssignment(symbol.Name, startValue); } else { startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, id, startValue); } } var step = (ExpressionSyntax)stmt.StepClause?.StepValue.Accept(_nodesVisitor); PrefixUnaryExpressionSyntax value = step.SkipParens() as PrefixUnaryExpressionSyntax; ExpressionSyntax condition; // In Visual Basic, the To expression is only evaluated once, but in C# will be evaluated every loop. // If it could evaluate differently or has side effects, it must be extracted as a variable var preLoopStatements = new List <SyntaxNode>(); var csToValue = (ExpressionSyntax)stmt.ToValue.Accept(_nodesVisitor); if (!_semanticModel.GetConstantValue(stmt.ToValue).HasValue) { var loopToVariableName = GetUniqueVariableNameInScope(node, "loopTo"); var loopEndDeclaration = SyntaxFactory.LocalDeclarationStatement(CommonConversions.CreateVariableDeclarationAndAssignment(loopToVariableName, csToValue)); // Does not do anything about porting newline trivia upwards to maintain spacing above the loop preLoopStatements.Add(loopEndDeclaration); csToValue = SyntaxFactory.IdentifierName(loopToVariableName); } ; if (value == null) { condition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, csToValue); } else { condition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, csToValue); } if (step == null) { step = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id); } else { step = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, step); } var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor))); var forStatementSyntax = SyntaxFactory.ForStatement( declaration, declaration != null ? SyntaxFactory.SeparatedList <ExpressionSyntax>() : SyntaxFactory.SingletonSeparatedList(startValue), condition, SyntaxFactory.SingletonSeparatedList(step), block.UnpackNonNestedBlock()); return(SyntaxFactory.List(preLoopStatements.Concat(new[] { forStatementSyntax }))); }
public Dictionary <string, VariableDeclarationSyntax> SplitVariableDeclarations( VariableDeclaratorSyntax declarator, bool preferExplicitType = false) { var rawType = ConvertDeclaratorType(declarator, preferExplicitType); var initializer = ConvertInitializer(declarator); var newDecls = new Dictionary <string, VariableDeclarationSyntax>(); foreach (var name in declarator.Names) { var(type, adjustedInitializer) = AdjustFromName(rawType, name, initializer); var equalsValueClauseSyntax = adjustedInitializer == null ? null : SyntaxFactory.EqualsValueClause(adjustedInitializer); var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax); string k = type.ToString(); if (newDecls.TryGetValue(k, out var decl)) { newDecls[k] = decl.AddVariables(v); } else { newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v)); } } return(newDecls); }
/// <summary> /// Generates syntax for an invoke method. /// </summary> /// <param name="grainType"> /// The grain type. /// </param> /// <param name="invokeMethod"> /// The invoke method to generate. /// </param> /// <returns> /// Syntax for an invoke method. /// </returns> private static MethodDeclarationSyntax GenerateInvokeMethod(Type grainType, MethodInfo invokeMethod) { var parameters = invokeMethod.GetParameters(); var grainArgument = parameters[0].Name.ToIdentifierName(); var requestArgument = parameters[1].Name.ToIdentifierName(); // Store the relevant values from the request in local variables. var interfaceIdDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(typeof(int).GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("interfaceId") .WithInitializer(SF.EqualsValueClause(requestArgument.Member((InvokeMethodRequest _) => _.InterfaceId))))); var interfaceIdVariable = SF.IdentifierName("interfaceId"); var methodIdDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(typeof(int).GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("methodId") .WithInitializer(SF.EqualsValueClause(requestArgument.Member((InvokeMethodRequest _) => _.MethodId))))); var methodIdVariable = SF.IdentifierName("methodId"); var argumentsDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(typeof(object[]).GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("arguments") .WithInitializer(SF.EqualsValueClause(requestArgument.Member((InvokeMethodRequest _) => _.Arguments))))); var argumentsVariable = SF.IdentifierName("arguments"); var methodDeclaration = invokeMethod.GetDeclarationSyntax() .AddBodyStatements(interfaceIdDeclaration, methodIdDeclaration, argumentsDeclaration); var interfaceCases = CodeGeneratorCommon.GenerateGrainInterfaceAndMethodSwitch( grainType, methodIdVariable, methodType => GenerateInvokeForMethod(grainType, grainArgument, methodType, argumentsVariable)); // Generate the default case, which will throw a NotImplementedException. var errorMessage = SF.BinaryExpression( SyntaxKind.AddExpression, "interfaceId=".GetLiteralExpression(), interfaceIdVariable); var throwStatement = SF.ThrowStatement( SF.ObjectCreationExpression(typeof(NotImplementedException).GetTypeSyntax()) .AddArgumentListArguments(SF.Argument(errorMessage))); var defaultCase = SF.SwitchSection().AddLabels(SF.DefaultSwitchLabel()).AddStatements(throwStatement); var interfaceIdSwitch = SF.SwitchStatement(interfaceIdVariable).AddSections(interfaceCases.ToArray()).AddSections(defaultCase); // If the provided grain is null, throw an argument exception. var argumentNullException = SF.ObjectCreationExpression(typeof(ArgumentNullException).GetTypeSyntax()) .AddArgumentListArguments(SF.Argument(parameters[0].Name.GetLiteralExpression())); var grainArgumentCheck = SF.IfStatement( SF.BinaryExpression( SyntaxKind.EqualsExpression, grainArgument, SF.LiteralExpression(SyntaxKind.NullLiteralExpression)), SF.ThrowStatement(argumentNullException)); return(methodDeclaration.AddBodyStatements(grainArgumentCheck, interfaceIdSwitch)); }