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 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));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IField;
var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name);
var returnTypeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(itemAsT.ReturnType).First();
var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT);
if (itemAsT.IsReadOnly)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
}
if (itemAsT.IsConstant)
{
modifiers = modifiers.Remove(modifiers.Where(x => x.Kind() == SyntaxKind.StaticKeyword).First());
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.ConstKeyword));
}
if (itemAsT.IsVolatile)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.VolatileKeyword));
}
var declaratorNode = SyntaxFactory.VariableDeclarator(nameSyntax);
if (itemAsT.Initializer != null)
{
var expressionSyntax = (ExpressionSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.Initializer);
expressionSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(expressionSyntax, itemAsT.Whitespace2Set[LanguageElement.Expression]);
var equalsToken = SyntaxFactory.Token(SyntaxKind.EqualsToken);
equalsToken = BuildSyntaxHelpers.AttachWhitespaceToToken(equalsToken, itemAsT.Whitespace2Set[LanguageElement.EqualsAssignmentOperator]);
var equalsValueClause = SyntaxFactory.EqualsValueClause(equalsToken, expressionSyntax);
declaratorNode = declaratorNode.WithInitializer(equalsValueClause);
}
declaratorNode = BuildSyntaxHelpers.AttachWhitespace(declaratorNode, itemAsT.Whitespace2Set, WhitespaceLookup);
var variableNode = SyntaxFactory.VariableDeclaration(returnTypeSyntax)
.WithVariables(
SyntaxFactory.SingletonSeparatedList(declaratorNode));
//variableNode = BuildSyntaxHelpers.AttachWhitespace(variableNode, itemAsField.Whitespace2Set, WhitespaceLookup);
var node = SyntaxFactory.FieldDeclaration(variableNode)
.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));
}
public static BaseListSyntax GetBaseList(IEnum item)
{
if (item.UnderlyingType != null)
{
var underlyingTypeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxNode(item.UnderlyingType);
underlyingTypeSyntax = BuildSyntaxHelpers.AttachWhitespace(
underlyingTypeSyntax, item.UnderlyingType.Whitespace2Set, whitespaceLookup);
var colonToken = SyntaxFactory.Token(SyntaxKind.ColonToken);
colonToken = BuildSyntaxHelpers.AttachWhitespaceToToken(colonToken, item.Whitespace2Set[LanguageElement.BaseListPrefix]);
return(SyntaxFactory.BaseList(colonToken,
SyntaxFactory.SingletonSeparatedList <BaseTypeSyntax>(SyntaxFactory.SimpleBaseType(underlyingTypeSyntax))));
}
return(null);
}
private IEnumerable <SyntaxNode> BuildSyntaxLocal(IVariableDeclaration itemAsT, TypeSyntax typeSyntax)
{
var node = SyntaxFactory.VariableDeclarator(itemAsT.Name);
if (itemAsT.Initializer != null)
{
var expressionSyntax = (ExpressionSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.Initializer);
expressionSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(expressionSyntax, itemAsT.Whitespace2Set[LanguageElement.Expression]);
var equalsToken = SyntaxFactory.Token(SyntaxKind.EqualsToken);
equalsToken = BuildSyntaxHelpers.AttachWhitespaceToToken(equalsToken, itemAsT.Whitespace2Set[LanguageElement.EqualsAssignmentOperator]);
var equalsValueClause = SyntaxFactory.EqualsValueClause(equalsToken, expressionSyntax);
//equalsValueClause = BuildSyntaxHelpers.AttachWhitespace(equalsValueClause, itemAsT.Whitespace2Set, WhitespaceLookup);
node = node.WithInitializer(equalsValueClause);
}
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
// Not a statement, so should not call PrepareForBuildSyntaxOutput
return(new SyntaxNode[] { node });
}
// Not sure if this belongs here or in BuildSyntaxHelpers
public TypeSyntax TypeSyntaxFromType(IReferencedType type)
{
// Type syntax is realy ugly to build, so I build it and then hack hte type arg whitespace
var typeName = CleanName(type);
if (type.TypeArguments.Any())
{
typeName += "<";
foreach (var tArg in type.TypeArguments)
{
var display = BuildSyntax(tArg).FirstOrDefault().ToFullString();
typeName += display;
typeName += (tArg == type.TypeArguments.Last()
? ""
: ", ");
//typeName += tArg.QualifiedName +
// (tArg == type.TypeArguments.Last()
// ? ""
// : ", ");
}
typeName += ">";
}
if (type.IsArray)
{
typeName += "[]";
}
var node = SyntaxFactory.ParseTypeName(typeName);
var typeArgNode = node.ChildNodes().OfType <TypeArgumentListSyntax>().FirstOrDefault();
if (typeArgNode != null)
{
var newStartToken = BuildSyntaxHelpers.AttachWhitespaceToToken(typeArgNode.LessThanToken,
type.Whitespace2Set[LanguageElement.TypeParameterStartDelimiter]);
var newEndToken = BuildSyntaxHelpers.AttachWhitespaceToToken(typeArgNode.GreaterThanToken,
type.Whitespace2Set[LanguageElement.TypeParameterEndDelimiter]);
var newTypeArgNode = typeArgNode.WithLessThanToken(newStartToken).WithGreaterThanToken(newEndToken);
//var newTypeArgNode = typeArgNode.WithLessThanToken(newStartToken);
node = node.ReplaceNode(typeArgNode, newTypeArgNode);
}
return(node);
}
