public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IArgument; var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT); var expressionSyntax = (ExpressionSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.ValueExpression); expressionSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(expressionSyntax, itemAsT.Whitespace2Set[LanguageElement.Expression]); var node = SyntaxFactory.Argument(expressionSyntax); if (itemAsT.IsOut) { node = node.WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)); } else if (itemAsT.IsRef) { node = node.WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)); } node = BuildSyntaxHelpers.AttachWhitespaceToFirst(node, itemAsT.Whitespace2Set[LanguageElement.OutModifier]); node = BuildSyntaxHelpers.AttachWhitespaceToFirst(node, itemAsT.Whitespace2Set[LanguageElement.RefModifier]); node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, WhitespaceLookup); node = BuildSyntaxHelpers.AttachWhitespaceToFirst(node, item.Whitespace2Set[LanguageElement.ParameterFirstToken]); node = BuildSyntaxHelpers.AttachWhitespaceToLast(node, item.Whitespace2Set[LanguageElement.ParameterLastToken]); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
private NamespaceDeclarationSyntax BuidSyntax(INamespace itemAsNamespace, IdentifierNameSyntax identifier) { var node = SyntaxFactory.NamespaceDeclaration(identifier); Guardian.Assert.IsNotNull(itemAsNamespace, nameof(itemAsNamespace)); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsNamespace.Whitespace2Set, WhitespaceLookup); var usingDirectives = itemAsNamespace.UsingDirectives .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)); var usingsSyntax = usingDirectives .OfType <UsingDirectiveSyntax>() .ToList(); if (usingsSyntax.Count() > 0) { node = node.WithUsings(SyntaxFactory.List <UsingDirectiveSyntax>(usingsSyntax)); } var membersSyntax = itemAsNamespace.StemMembers .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .OfType <MemberDeclarationSyntax>() .ToList(); if (membersSyntax.Count() > 0) { node = node.WithMembers(SyntaxFactory.List <MemberDeclarationSyntax>(membersSyntax)); } return(node); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IEnumMember; Guardian.Assert.IsNotNull(itemAsT, nameof(itemAsT)); var identifier = SyntaxFactory.Identifier(itemAsT.Name); var node = SyntaxFactory.EnumMemberDeclaration(identifier); var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes); if (attributes.Any()) { node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes)); } if (itemAsT.Expression != null) { if (itemAsT.Expression.InitialExpressionLanguage != ExpectedLanguages.CSharp) { throw new InvalidOperationException(); } var exprSyntax = SyntaxFactory.ParseExpression(itemAsT.Expression.InitialExpressionString); var equalsValueSyntax = SyntaxFactory.EqualsValueClause(exprSyntax); equalsValueSyntax = BuildSyntaxHelpers.AttachWhitespace(equalsValueSyntax, item.Whitespace2Set, WhitespaceLookup); node = node.WithEqualsValue(equalsValueSyntax); } node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, WhitespaceLookup); //node = BuildSyntaxHelpers.AttachWhitespaceToFirst(node, item.Whitespace2Set[LanguageElement.EnumValueFirstToken]); //node = BuildSyntaxHelpers.AttachWhitespaceToLast(node, item.Whitespace2Set[LanguageElement.EnumValueLastToken]); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
private IEnumerable <CatchClauseSyntax> BuildCatchSyntaxList(ITryStatement itemAsT) { var ret = new List <CatchClauseSyntax>(); foreach (var ctch in itemAsT.Catches) { var syntax = SyntaxFactory.CatchClause(); if (ctch.ExceptionType != null) { TypeSyntax typeSyntax = (TypeSyntax)(RDom.CSharp.GetSyntaxNode(ctch.ExceptionType)); var declaration = SyntaxFactory.CatchDeclaration(typeSyntax); if (ctch.Variable != null) { declaration = declaration.WithIdentifier(SyntaxFactory.Identifier(ctch.Variable.Name)); } declaration = BuildSyntaxHelpers.AttachWhitespace(declaration, ctch.Whitespace2Set, WhitespaceLookup); syntax = syntax.WithDeclaration(declaration); } // TODO: Add catch filter for 6.0 // TODO: Empty statement would return empty brackets here? var block = BuildSyntaxWorker.GetStatementBlock(ctch.Statements); block = BuildSyntaxHelpers.AttachWhitespace(block, ctch.Whitespace2Set, WhitespaceLookup); syntax = syntax.WithBlock(block); syntax = BuildSyntaxHelpers.AttachWhitespace(syntax, ctch.Whitespace2Set, WhitespaceLookup); ret.Add(syntax); } return(ret); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as T; SyntaxNode node; if (itemAsT.Condition == null) // TODO: Isn't condition null in a ForEach? { node = SyntaxFactory.EmptyStatement(); } // This shold not happen else { var statement = RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup); var condition = (ExpressionSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.Condition); node = MakeSyntax(itemAsT, condition, statement); } var leadingTrivia = BuildSyntaxHelpers.LeadingTrivia(itemAsT, OutputContext); node = node.WithLeadingTrivia(leadingTrivia); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); node = AdjustWhitespace(node, itemAsT, WhitespaceLookup); return(node.PrepareForBuildSyntaxOutput(itemAsT, OutputContext)); }
public TypeSyntax GetVariableTypeSyntax(bool isImplicitlyTyped, IReferencedType type) { TypeSyntax typeSyntax; if (isImplicitlyTyped) { typeSyntax = SyntaxFactory.ParseTypeName("var"); typeSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(typeSyntax, type.Whitespace2Set.First()); } else { typeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(type).First(); } return(typeSyntax); //if (itemAsVariable.IsImplicitlyTyped) //{ return SyntaxFactory.IdentifierName("var"); } //var type = itemAsVariable.Type; //if (itemAsVariable.IsAliased) //{ // var typeName = Mappings.AliasFromSystemType(type.Name); // return SyntaxFactory.IdentifierName(typeName); //} //return (TypeSyntax)(RDomCSharp.Factory.BuildSyntax(type)); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IInvocationExpression; if (!string.IsNullOrWhiteSpace(itemAsT.InitialExpressionLanguage) && itemAsT.InitialExpressionLanguage != ExpectedLanguages.CSharp) { throw new InvalidOperationException(); } SyntaxNode node; if (itemAsT.MethodName != null) { var methodName = SyntaxFactory.ParseExpression(GetMethodName(itemAsT)); node = SyntaxFactory.ParseExpression(methodName + "()"); var argList = itemAsT.Arguments .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .OfType <ArgumentSyntax>() .ToList(); var argListSyntax = SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList(argList)); argListSyntax = BuildSyntaxHelpers.AttachWhitespace(argListSyntax, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Initializer); node = (node as InvocationExpressionSyntax).WithArgumentList(argListSyntax); } else { node = SyntaxFactory.ParseExpression(itemAsT.InitialExpressionString); } return(new SyntaxNode[] { node }); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IUsingStatement; var statement = RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup); var node = SyntaxFactory.UsingStatement(statement); if (itemAsT.Variable != null) { //var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.Variable); var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax( itemAsT.Variable.IsImplicitlyTyped, itemAsT.Variable.Type); var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Variable.Initializer); var equalsValueClause = SyntaxFactory.EqualsValueClause((ExpressionSyntax)expressionSyntax); equalsValueClause = BuildSyntaxHelpers.AttachWhitespace(equalsValueClause, itemAsT.Variable.Whitespace2Set, WhitespaceLookup); var nodeDeclarator = SyntaxFactory.VariableDeclarator(itemAsT.Variable.Name); nodeDeclarator = nodeDeclarator.WithInitializer(equalsValueClause); nodeDeclarator = BuildSyntaxHelpers.AttachWhitespace(nodeDeclarator, itemAsT.Variable.Whitespace2Set, WhitespaceLookup); var nodeDeclaratorInList = SyntaxFactory.SeparatedList(SyntaxFactory.List <VariableDeclaratorSyntax>(new VariableDeclaratorSyntax[] { (VariableDeclaratorSyntax)nodeDeclarator })); var nodeDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax, nodeDeclaratorInList); node = node.WithDeclaration(nodeDeclaration); } else { var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Expression) as ExpressionSyntax; node = node.WithExpression(expressionSyntax); } node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IConversionOperator; var kind = itemAsT.IsImplicit ? SyntaxKind.ImplicitKeyword : SyntaxKind.ExplicitKeyword; var opToken = SyntaxFactory.Token(kind); var typeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(itemAsT.Type).First(); var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT); var node = SyntaxFactory.ConversionOperatorDeclaration(opToken, typeSyntax) .WithModifiers(modifiers); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes); if (attributes.Any()) { node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes)); } //node = node.WithLeadingTrivia(BuildSyntaxHelpers.LeadingTrivia(item)); var parameterList = itemAsT.Parameters .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .OfType <ParameterSyntax>() .ToList(); var parameterListSyntax = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameterList)); parameterListSyntax = BuildSyntaxHelpers.AttachWhitespace(parameterListSyntax, itemAsT.Whitespace2Set, WhitespaceLookup); node = node.WithParameterList(parameterListSyntax); node = node.WithBody((BlockSyntax)RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup)); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IAttributeValue; var argNameSyntax = SyntaxFactory.IdentifierName(itemAsT.Name); argNameSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirst(argNameSyntax, item.Whitespace2Set[LanguageElement.AttributeValueName]); argNameSyntax = BuildSyntaxHelpers.AttachWhitespaceToLast(argNameSyntax, item.Whitespace2Set[LanguageElement.AttributeValueName]); //var kind = Mappings.SyntaxKindFromLiteralKind(itemAsT.ValueType, itemAsT.Value); ExpressionSyntax expr = BuildSyntaxHelpers.BuildArgValueExpression( itemAsT.Value, itemAsT.ValueConstantIdentifier, itemAsT.ValueType); var node = SyntaxFactory.AttributeArgument(expr); if (itemAsT.Style == AttributeValueStyle.Colon) { var nameColon = SyntaxFactory.NameColon(argNameSyntax); nameColon = BuildSyntaxHelpers.AttachWhitespaceToLast(nameColon, item.Whitespace2Set[LanguageElement.AttributeValueEqualsOrColon]); node = node.WithNameColon(nameColon); } else if (itemAsT.Style == AttributeValueStyle.Equals) { var nameEquals = SyntaxFactory.NameEquals(argNameSyntax); nameEquals = BuildSyntaxHelpers.AttachWhitespaceToLast(nameEquals, item.Whitespace2Set[LanguageElement.AttributeValueEqualsOrColon]); node = node.WithNameEquals(nameEquals); } node = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(node, item.Whitespace2Set[LanguageElement.AttributeValueValue]); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public static BaseListSyntax GetBaseList(IHasImplementedInterfaces item) { var list = new List <BaseTypeSyntax>(); var asClass = item as IClass; if (asClass != null) { if (asClass.BaseType != null) { var baseTypeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxNode(asClass.BaseType); var baseSyntax = SyntaxFactory.SimpleBaseType(baseTypeSyntax); list.Add(baseSyntax); } } foreach (var interf in item.ImplementedInterfaces) { var interfTypeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxNode(interf); var baseSyntax = SyntaxFactory.SimpleBaseType(interfTypeSyntax); list.Add(baseSyntax); } var colonToken = SyntaxFactory.Token(SyntaxKind.ColonToken); colonToken = BuildSyntaxHelpers.AttachWhitespaceToToken(colonToken, item.Whitespace2Set[LanguageElement.BaseListPrefix]); return(list.Any() ? SyntaxFactory.BaseList(colonToken, SyntaxFactory.SeparatedList <BaseTypeSyntax>(list)) : null); }
public static TSyntax BuildTypeParameterSyntax <TSyntax>(IHasTypeParameters itemAsT, TSyntax node, WhitespaceKindLookup whitespaceLookup, Func <TSyntax, TypeParameterListSyntax, TSyntax> addTypeParameters, Func <TSyntax, SyntaxList <TypeParameterConstraintClauseSyntax>, TSyntax> addTypeParameterConstraints) where TSyntax : SyntaxNode { // This works oddly because it uncollapses the list // This code is largely repeated in interface and class factories, but is very hard to refactor because of shallow Roslyn (Microsoft) architecture var typeParamsAndConstraints = itemAsT.TypeParameters .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .ToList(); var typeParameterSyntaxList = BuildSyntaxHelpers.GetTypeParameterSyntaxList( typeParamsAndConstraints, itemAsT.Whitespace2Set, whitespaceLookup); if (typeParameterSyntaxList != null) { node = addTypeParameters(node, typeParameterSyntaxList); var clauses = BuildSyntaxHelpers.GetTypeParameterConstraintList( typeParamsAndConstraints, itemAsT.Whitespace2Set, whitespaceLookup); if (clauses.Any()) { node = addTypeParameterConstraints(node, clauses); } } return(node); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IDeclarationStatement; var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name); var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.IsImplicitlyTyped, itemAsT.Type); var variable = item as IVariableDeclaration; // This is a weakness in the current factory lookup - we can't just ask for a random factory // so to call the normal build syntax through the factory causes infinite recursion. // TODO: Add the ability to request a random factory from the container (via the CSharp uber factory var tempFactory = new RDomVariableDeclarationFactory(OutputContext.Corporation); var nodeDeclarators = tempFactory.BuildSyntax(item); var nodeDeclarator = (VariableDeclaratorSyntax)nodeDeclarators.First(); var nodeDeclaratorInList = SyntaxFactory.SeparatedList( SyntaxFactory.List <VariableDeclaratorSyntax>( new VariableDeclaratorSyntax[] { nodeDeclarator })); var nodeDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax, nodeDeclaratorInList); nodeDeclaration = BuildSyntaxHelpers.AttachWhitespace(nodeDeclaration, itemAsT.Whitespace2Set, WhitespaceLookup); var node = SyntaxFactory.LocalDeclarationStatement(nodeDeclaration); if (itemAsT.IsConst) { node = node.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ConstKeyword))); } node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public static StatementSyntax BuildStatement(IEnumerable <IStatement> statements, IStatementBlock parent, WhitespaceKindLookup whitespaceLookup) { StatementSyntax statementBlock; var statementSyntaxList = statements .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .ToList(); var hasBlock = parent.HasBlock; if (hasBlock || statements.Count() > 1) { statementBlock = SyntaxFactory.Block(SyntaxFactory.List(statementSyntaxList)); statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup); // Block tokens are held in parent } else if (statements.Count() == 1) { statementBlock = (StatementSyntax)statementSyntaxList.First(); //statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup); } else { statementBlock = SyntaxFactory.EmptyStatement(); statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup); } return(statementBlock); }
protected override ForStatementSyntax MakeSyntax(RDomForStatement itemAsT, ExpressionSyntax condition, StatementSyntax statementBlock) { var declaratorSyntax = (VariableDeclaratorSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.Variable); var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax( itemAsT.Variable.IsImplicitlyTyped, itemAsT.Variable.Type); //var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.Variable); var nodeDeclaratorInList = SyntaxFactory.SeparatedList(SyntaxFactory.List <VariableDeclaratorSyntax>(new VariableDeclaratorSyntax[] { declaratorSyntax })); var nodeDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax, nodeDeclaratorInList); nodeDeclaration = BuildSyntaxHelpers.AttachWhitespace(nodeDeclaration, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Variable); var incrementorSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Incrementor); incrementorSyntax = BuildSyntaxHelpers.AttachWhitespace(incrementorSyntax, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Iterator); var secondSemiColonToken = SyntaxFactory.Token(SyntaxKind.SemicolonToken); secondSemiColonToken = triviaManager.AttachWhitespaceToToken(secondSemiColonToken, itemAsT.Whitespace2Set[LanguagePart.Condition, LanguageElement.EndOfLine]); var node = SyntaxFactory.ForStatement(statementBlock) .WithCondition(condition) .WithDeclaration(nodeDeclaration) .WithIncrementors(SyntaxFactory.SeparatedList <ExpressionSyntax>(new ExpressionSyntax[] { (ExpressionSyntax)incrementorSyntax })) .WithSecondSemicolonToken(secondSemiColonToken); return(node); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IEvent; var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name); var typeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(itemAsT.Type).First(); var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT); var variableNode = SyntaxFactory.VariableDeclarator(nameSyntax); var variableNodes = SyntaxFactory.SeparatedList(new VariableDeclaratorSyntax[] { variableNode }); var eventNode = SyntaxFactory.VariableDeclaration(typeSyntax, variableNodes); eventNode = BuildSyntaxHelpers.AttachWhitespace(eventNode, itemAsT.Whitespace2Set, WhitespaceLookup); var node = SyntaxFactory.EventFieldDeclaration(eventNode) .WithModifiers(modifiers); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes); if (attributes.Any()) { node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes)); } return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
private IEnumerable <SyntaxNode> BuildSyntax(IAttribute item) { var itemAsT = item as IAttribute; var nameSyntax = SyntaxFactory.ParseName(itemAsT.Name); var node = SyntaxFactory.Attribute(nameSyntax); node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, WhitespaceLookup); var attributeArgList = itemAsT.AttributeValues .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .OfType <AttributeArgumentSyntax>() .ToList(); if (attributeArgList.Any()) { var argList = SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList(attributeArgList)); argList = BuildSyntaxHelpers.AttachWhitespace(argList, item.Whitespace2Set, WhitespaceLookup); node = node.WithArgumentList(argList); } var nodeList = SyntaxFactory.AttributeList( SyntaxFactory.SeparatedList( new AttributeSyntax[] { (AttributeSyntax)BuildSyntaxHelpers.PrepareForBuildItemSyntaxOutput(node, item, OutputContext) })); nodeList = BuildSyntaxHelpers.AttachWhitespace(nodeList, item.Whitespace2Set, WhitespaceLookup); return(nodeList.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IAssignmentStatement; var leftSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Left); leftSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(leftSyntax, itemAsT.Whitespace2Set[LanguageElement.LeftExpression]); var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Expression); expressionSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(expressionSyntax, itemAsT.Whitespace2Set[LanguageElement.Expression]); var syntaxKind = Mappings.SyntaxKindFromAssignmentOperator(itemAsT.Operator); var opToken = SyntaxFactory.Token(Mappings.SyntaxTokenKindFromAssignmentOperator(itemAsT.Operator)); opToken = BuildSyntaxHelpers.AttachWhitespaceToToken(opToken, itemAsT.Whitespace2Set[LanguageElement.AssignmentOperator]); var assignmentSyntax = SyntaxFactory.AssignmentExpression(syntaxKind, (ExpressionSyntax)leftSyntax, opToken, (ExpressionSyntax)expressionSyntax); assignmentSyntax = BuildSyntaxHelpers.AttachWhitespace(assignmentSyntax, itemAsT.Whitespace2Set, WhitespaceLookup); var node = SyntaxFactory.ExpressionStatement(assignmentSyntax); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
private SyntaxNode GetConstraintClause(string name, ITypeParameter itemAsT) { var list = new List <TypeParameterConstraintSyntax>(); if (itemAsT.HasValueTypeConstraint) { list.Add(SyntaxFactory.ClassOrStructConstraint(SyntaxKind.StructConstraint)); } else if (itemAsT.HasReferenceTypeConstraint) { list.Add(SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint)); } foreach (var typeConstraint in itemAsT.ConstraintTypes) { var typeSyntax = (TypeSyntax)RDom.CSharp .GetSyntaxNode(typeConstraint); var typeConstraintSyntax = SyntaxFactory.TypeConstraint(typeSyntax); list.Add(typeConstraintSyntax); } // New has to be last if (itemAsT.HasConstructorConstraint) { var constructorConstraint = SyntaxFactory.ConstructorConstraint(); constructorConstraint = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(constructorConstraint, itemAsT.Whitespace2Set[LanguageElement.ConstructorConstraint]); list.Add(constructorConstraint); } var syntax = SyntaxFactory.TypeParameterConstraintClause(name) .WithConstraints(SyntaxFactory.SeparatedList(list)); syntax = BuildSyntaxHelpers.AttachWhitespace(syntax, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Constraint); return(syntax); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsNamespace = item as INamespace; var identifier = SyntaxFactory.IdentifierName(itemAsNamespace.Name); var node = SyntaxFactory.NamespaceDeclaration(identifier); Guardian.Assert.IsNotNull(itemAsNamespace, nameof(itemAsNamespace)); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsNamespace.Whitespace2Set, WhitespaceLookup); var usingDirectives = itemAsNamespace.UsingDirectives .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)); var usingsSyntax = usingDirectives .OfType <UsingDirectiveSyntax>() .ToList(); if (usingsSyntax.Count() > 0) { node = node.WithUsings(SyntaxFactory.List <UsingDirectiveSyntax>(usingsSyntax)); } var membersSyntax = itemAsNamespace.StemMembers .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .OfType <MemberDeclarationSyntax>() .ToList(); if (membersSyntax.Count() > 0) { node = node.WithMembers(SyntaxFactory.List <MemberDeclarationSyntax>(membersSyntax)); } return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
private ElseClauseSyntax BuildElseSyntax(IIfStatement itemAsT) { // Because we reversed the list, inner is first, inner to outer required for this approach var elses = itemAsT.Elses.Reverse(); var lastItem = itemAsT; ElseClauseSyntax elseClause = null; foreach (var nestedElse in elses) { var statement = GetStatement(nestedElse); var elseIf = nestedElse as IElseIfStatement; if (elseIf != null) { // build if statement and put in else clause statement = SyntaxFactory.IfStatement(GetCondition(elseIf), statement) .WithElse(elseClause); statement = BuildSyntaxHelpers.AttachWhitespace(statement, nestedElse.Whitespace2Set, WhitespaceLookup); } var newElseClause = SyntaxFactory.ElseClause(statement); newElseClause = BuildSyntaxHelpers.AttachWhitespace(newElseClause, nestedElse.Whitespace2Set, WhitespaceLookup); elseClause = newElseClause; lastItem = itemAsT; } return(elseClause); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IContinueStatement; var node = SyntaxFactory.ContinueStatement(); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
private ExpressionSyntax GetCondition(IHasCondition itemAsT) { var expression = (ExpressionSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.Condition); expression = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(expression, itemAsT.Whitespace2Set[LanguageElement.Expression]); return(expression); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IBlockStatement; var block = BuildSyntaxWorker.GetStatementBlock(itemAsT.Statements); var node = SyntaxFactory.Block(SyntaxFactory.List(block.Statements)); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IInvocationStatement; var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Invocation); var node = SyntaxFactory.ExpressionStatement((ExpressionSyntax)expressionSyntax); node = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(node, itemAsT.Whitespace2Set[LanguageElement.Expression]); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as ILockStatement; var statement = RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup); var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Expression) as ExpressionSyntax; var node = SyntaxFactory.LockStatement(expressionSyntax, statement); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IClass; Guardian.Assert.IsNotNull(itemAsT, nameof(itemAsT)); var modifiers = item.BuildModfierSyntax(); if (itemAsT.IsAbstract) { modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); } if (itemAsT.IsSealed) { modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword)); } if (itemAsT.IsPartial) { modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword)); } var identifier = SyntaxFactory.Identifier(itemAsT.Name); var node = SyntaxFactory.ClassDeclaration(identifier) .WithModifiers(modifiers); node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, whitespaceLookup); var baseList = BuildSyntaxHelpers.GetBaseList(itemAsT); if (baseList != null) { node = node.WithBaseList(baseList); } var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes); if (attributes.Any()) { node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes)); } var membersSyntax = itemAsT.Members .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .ToList(); node = node.WithMembers(SyntaxFactory.List(membersSyntax)); node = BuildSyntaxHelpers.BuildTypeParameterSyntax( itemAsT, node, whitespaceLookup, (x, p) => x.WithTypeParameterList(p), (x, c) => x.WithConstraintClauses(c)); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IParameter; Guardian.Assert.IsNotNull(itemAsT, nameof(itemAsT)); var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name); var syntaxType = (TypeSyntax)(RDom.CSharp.GetSyntaxNode(itemAsT.Type)); syntaxType = BuildSyntaxHelpers.RemoveLeadingSpaces(syntaxType); var node = SyntaxFactory.Parameter(nameSyntax) .WithType(syntaxType); if (itemAsT.DefaultValueType != LiteralKind.Unknown) { var defaultValueExpression = BuildSyntaxHelpers.BuildArgValueExpression( itemAsT.DefaultValue, itemAsT.DefaultConstantIdentifier, itemAsT.DefaultValueType); var defaultClause = SyntaxFactory.EqualsValueClause(defaultValueExpression); defaultClause = BuildSyntaxHelpers.AttachWhitespace(defaultClause, item.Whitespace2Set, WhitespaceLookup); node = node.WithDefault(defaultClause); } var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes); if (attributes.Any()) { node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes)); } var modifiers = SyntaxFactory.TokenList(); if (itemAsT.IsOut) { modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.OutKeyword)); } if (itemAsT.IsRef) { modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.RefKeyword)); } if (itemAsT.IsParamArray) { modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.ParamsKeyword)); } if (modifiers.Any()) { node = node.WithModifiers(modifiers); } node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, WhitespaceLookup); node = BuildSyntaxHelpers.AttachWhitespaceToFirst(node, item.Whitespace2Set[LanguageElement.ParameterFirstToken]); node = BuildSyntaxHelpers.AttachWhitespaceToLast(node, item.Whitespace2Set[LanguageElement.ParameterLastToken]); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as ICheckedStatement; var statement = RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup) as BlockSyntax; var kind = itemAsT.Unchecked ? SyntaxKind.UncheckedStatement : SyntaxKind.CheckedStatement; var node = SyntaxFactory.CheckedStatement(kind, statement); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item) { var itemAsT = item as IConstructor; var parent = item.Parent as IClass; SyntaxToken nameSyntax; if (parent == null) { nameSyntax = SyntaxFactory.Identifier("unknown_name"); } else { nameSyntax = SyntaxFactory.Identifier(parent.Name); } var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT); var node = SyntaxFactory.ConstructorDeclaration(nameSyntax) .WithModifiers(modifiers); node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup); var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes); if (attributes.Any()) { node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes)); } var parameterList = itemAsT.Parameters .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .OfType <ParameterSyntax>() .ToList(); var parameterListSyntax = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameterList)); parameterListSyntax = BuildSyntaxHelpers.AttachWhitespace(parameterListSyntax, itemAsT.Whitespace2Set, WhitespaceLookup); node = node.WithParameterList(parameterListSyntax); //node = node.WithLeadingTrivia(BuildSyntaxHelpers.LeadingTrivia(item)); node = node.WithBody((BlockSyntax)RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup)); var initializer = BuildInitializer(itemAsT); if (initializer != null) { initializer = BuildSyntaxHelpers.AttachWhitespace(initializer, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Initializer); node = node.WithInitializer(initializer); } return(node.PrepareForBuildSyntaxOutput(item, OutputContext)); }