public static StatementSyntax EmitSyntax(AbstractStatement statement) { if (statement is ReturnStatement statementReturn) { return(SyntaxFactory.ReturnStatement(ExpressionSyntaxEmitter.EmitSyntax(statementReturn.Expression))); } if (statement is BlockStatement statementBlock) { return(statementBlock.ToSyntax()); } if (statement is ThrowStatement statementThrow) { return(SyntaxFactory.ThrowStatement(ExpressionSyntaxEmitter.EmitSyntax(statementThrow.Exception))); } if (statement is ExpressionStatement statementExpression) { return(SyntaxFactory.ExpressionStatement(ExpressionSyntaxEmitter.EmitSyntax(statementExpression.Expression))); } if (statement is VariableDeclarationStatement statementVariable) { return(EmitLocalDeclarationSyntax(statementVariable)); } if (statement is IfStatement statementIf) { return(EmitIfStatementSyntax(statementIf)); } if (statement is LockStatement statementLock) { return(SyntaxFactory.LockStatement(ExpressionSyntaxEmitter.EmitSyntax(statementLock.SyncRoot), statementLock.Body.ToSyntax())); } //TODO: support other types of statements throw new NotSupportedException($"Syntax emitter is not supported for statement of type '{statement.GetType().Name}'."); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- private static StatementSyntax EmitIfStatementSyntax(IfStatement statement) { var syntax = SyntaxFactory.IfStatement(ExpressionSyntaxEmitter.EmitSyntax(statement.Condition), statement.ThenBlock.ToSyntax()); if (statement.ElseBlock != null) { syntax = syntax.WithElse(SyntaxFactory.ElseClause(statement.ElseBlock.ToSyntax())); } return(syntax); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- private static ArgumentSyntax EmitArgument(Argument argument) { var syntax = SyntaxFactory.Argument(ExpressionSyntaxEmitter.EmitSyntax(argument.Expression)); switch (argument.Modifier) { case MethodParameterModifier.Ref: syntax = syntax.WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)); break; case MethodParameterModifier.Out: syntax = syntax.WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)); break; } return(syntax); }
public static AttributeSyntax EmitSyntax(AttributeDescription description) { var syntax = SyntaxFactory.Attribute(SyntaxHelpers.GetTypeFullNameSyntax(description.AttributeType, stripSuffix: "Attribute")); if (description.ConstructorArguments.Count > 0 || description.PropertyValues.Count > 0) { syntax = syntax .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList <AttributeArgumentSyntax>( description.ConstructorArguments.Select(arg => SyntaxFactory.AttributeArgument(SyntaxHelpers.GetLiteralSyntax(arg))) .Concat(description.PropertyValues.Select(pv => SyntaxFactory.AttributeArgument(ExpressionSyntaxEmitter.EmitSyntax(pv.Value)) .WithNameEquals(SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(pv.Name))) )) ) ) ); } return(syntax); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- public override FieldDeclarationSyntax EmitSyntax() { var declarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(Member.Name)); if (Member.Initializer != null) { declarator = declarator.WithInitializer(SyntaxFactory.EqualsValueClause(ExpressionSyntaxEmitter.EmitSyntax(Member.Initializer))); } OutputSyntax = SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration( Member.Type.GetTypeNameSyntax() ) .WithVariables( SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>( declarator ) ) ) .WithModifiers( EmitMemberModifiers() ); //TODO: emit attributes return(OutputSyntax); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- private static LocalDeclarationStatementSyntax EmitLocalDeclarationSyntax(VariableDeclarationStatement statement) { var variable = statement.Variable; var declaration = (variable.Type != null ? SyntaxFactory.VariableDeclaration(variable.Type.GetTypeNameSyntax()) : SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var"))); var declarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(variable.Name)); if (statement.InitialValue != null) { declarator = declarator.WithInitializer(SyntaxFactory.EqualsValueClause(ExpressionSyntaxEmitter.EmitSyntax(statement.InitialValue))); } return(SyntaxFactory.LocalDeclarationStatement(declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declarator)))); }