private void MemberWhitespace(RDomEnumMember newItem, EnumMemberDeclarationSyntax syntax)
{
//CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetFirstToken(), LanguagePart.Current, LanguageElement.EnumValueFirstToken);
//CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetLastToken(), LanguagePart.Current, LanguageElement.EnumValueLastToken);
if (syntax.EqualsValue != null)
{
CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.EqualsValue.Value.GetLastToken(), LanguagePart.Current, LanguageElement.Expression);
CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.EqualsValue.EqualsToken, LanguagePart.Current, LanguageElement.EnumValueAssignOperator);
}
CreateFromWorker.StoreListMemberWhitespace(syntax,
WhitespaceLookup.Lookup(LanguageElement.EnumValueSeparator),
LanguageElement.Identifier, newItem);
//var prevNodeOrToken = syntax.Parent
// .ChildNodesAndTokens()
// .PreviousSiblings(syntax)
// .LastOrDefault();
//var sepKind = WhitespaceLookup.Lookup(LanguageElement.EnumValueSeparator);
//if (prevNodeOrToken.CSharpKind() == sepKind)
//{
// var commaToken = prevNodeOrToken.AsToken();
// var whitespace2 = newItem.Whitespace2Set[LanguageElement.Identifier];
// var newLeadingWhitespace = commaToken.TrailingTrivia.ToString();;
// if (string.IsNullOrEmpty(whitespace2.LeadingWhitespace)
// || newLeadingWhitespace.EndsWith("\r\n"))
// { whitespace2.LeadingWhitespace = newLeadingWhitespace
// + whitespace2.LeadingWhitespace; }
//}
}
private IEnumerable <IMisc> CreateFromVariableDeclaration(
VariableDeclarationSyntax syntax, SyntaxNode syntaxNode, IDom parent, SemanticModel model,
Func <SyntaxNode, IDom, SemanticModel, RDomBaseVariable> makeNewDelegate)
{
var list = new List <IMisc>();
var declarators = syntax.Variables.OfType <VariableDeclaratorSyntax>();
foreach (var decl in declarators)
{
var newItem = SetupNewVariable(VariableKind.Local,
makeNewDelegate(decl, parent, model),
syntax.Type, decl, parent, model);
var rDomItem = newItem as IRoslynDom;
list.Add(newItem);
CreateFromWorker.StoreWhitespace(newItem, decl, LanguagePart.Current, WhitespaceLookup);
if (decl.Initializer != null)
{
var equalsClause = decl.Initializer;
newItem.Initializer = OutputContext.Corporation.CreateSpecial <IExpression>(equalsClause.Value, newItem, model).FirstOrDefault();
//newItem.Initializer = (IExpression)OutputContext.Corporation.Create(equalsClause.Value, newItem, model).FirstOrDefault();
CreateFromWorker.StandardInitialize(newItem.Initializer, decl, parent, model, OutputContext);
CreateFromWorker.StoreWhitespaceForToken(newItem, decl.Initializer.EqualsToken, LanguagePart.Current, LanguageElement.EqualsAssignmentOperator);
CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, decl.Initializer, LanguagePart.Current, LanguageElement.Expression);
}
}
return(list);
}
private void MemberWhitespace(RDomParameter newItem, ParameterSyntax syntax)
{
CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetFirstToken(), LanguagePart.Current, LanguageElement.ParameterFirstToken);
CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetLastToken(), LanguagePart.Current, LanguageElement.ParameterLastToken);
CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup);
if (syntax.Default != null)
{
CreateFromWorker.StoreWhitespace(newItem, syntax.Default, LanguagePart.Current, WhitespaceLookup);
//CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.Default.Value.GetLastToken(), LanguagePart.Current, LanguageElement.Identifier);
//CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.Default.EqualsToken, LanguagePart.Current, LanguageElement.ParameterDefaultAssignOperator);
}
CreateFromWorker.StoreListMemberWhitespace(syntax,
WhitespaceLookup.Lookup(LanguageElement.ParameterSeparator),
LanguageElement.ParameterFirstToken, newItem);
//var prevNodeOrToken = syntax.Parent
// .ChildNodesAndTokens()
// .PreviousSiblings(syntax)
// .LastOrDefault();
//var sepKind = WhitespaceLookup.Lookup(LanguageElement.ParameterSeparator);
//if (prevNodeOrToken.CSharpKind() == sepKind)
//{
// var commaToken = prevNodeOrToken.AsToken();
// var whitespace2 = newItem.Whitespace2Set[LanguageElement.ParameterFirstToken];
// if (string.IsNullOrEmpty(whitespace2.LeadingWhitespace))
// { whitespace2.LeadingWhitespace = commaToken.TrailingTrivia.ToString(); }
//}
}
private void StoreWhitespaceForNamed(RDomAttributeValue newItem, AttributeArgumentSyntax syntax, SyntaxToken identifier, SyntaxToken op)
{
CreateFromWorker.StoreWhitespaceForToken(newItem, identifier,
LanguagePart.Current, LanguageElement.AttributeValueName);
CreateFromWorker.StoreWhitespaceForToken(newItem, op, LanguagePart.Current, LanguageElement.AttributeValueEqualsOrColon);
var lastToken = syntax.GetLastToken();
CreateFromWorker.StoreWhitespaceForToken(newItem, lastToken, LanguagePart.Current, LanguageElement.AttributeValueValue);
}
private void MemberWhitespace(RDomArgument newItem, ArgumentSyntax syntax)
{
CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetFirstToken(), LanguagePart.Current, LanguageElement.ParameterFirstToken);
CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetLastToken(), LanguagePart.Current, LanguageElement.ParameterLastToken);
CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreListMemberWhitespace(syntax,
WhitespaceLookup.Lookup(LanguageElement.ParameterSeparator),
LanguageElement.ParameterFirstToken, newItem);
}
private void StoreWhitespace(TypeSyntax typeSyntax, RDomReferencedType newItem)
{
//CreateFromWorker.StoreWhitespace(newItem, typeSyntax, LanguagePart.Current, whitespaceLookup);
var identifierToken = typeSyntax.ChildTokens()
.Where(x => x.CSharpKind() == SyntaxKind.IdentifierToken)
.FirstOrDefault();
CreateFromWorker.StoreWhitespaceForToken(newItem, identifierToken, LanguagePart.Current, LanguageElement.Identifier);
var firstToken = typeSyntax.GetFirstToken();
var lastToken = typeSyntax.GetLastToken();
if (identifierToken != firstToken)
{
CreateFromWorker.StoreWhitespaceForToken(newItem, firstToken, LanguagePart.Current, LanguageElement.FirstToken);
}
if (identifierToken != lastToken && lastToken.CSharpKind() != SyntaxKind.GreaterThanToken)
{
CreateFromWorker.StoreWhitespaceForToken(newItem, lastToken, LanguagePart.Current, LanguageElement.LastToken);
}
var typeArgumentList = typeSyntax.ChildNodes()
.OfType <TypeArgumentListSyntax>()
.FirstOrDefault();
if (typeArgumentList != null)
{
CreateFromWorker.StoreWhitespaceForToken(newItem, typeArgumentList.LessThanToken,
LanguagePart.Current, LanguageElement.TypeParameterStartDelimiter);
CreateFromWorker.StoreWhitespaceForToken(newItem, typeArgumentList.GreaterThanToken,
LanguagePart.Current, LanguageElement.TypeParameterEndDelimiter);
}
//// This is ugly, but there are so many uses for this class I had
//// trouble with the generalized StoreWhitespace doubling some
//// whitespace.
//var openTypeParam = typeSyntax.ChildTokens()
// .Where(x => x.CSharpKind() == SyntaxKind.LessThanToken)
// .FirstOrDefault();
//CreateFromWorker.StoreWhitespaceForToken(newItem, openTypeParam, LanguagePart.Current, LanguageElement.TypeParameterStartDelimiter);
//var closeTypeParam = typeSyntax.ChildTokens()
// .Where(x => x.CSharpKind() == SyntaxKind.GreaterThanToken)
// .FirstOrDefault();
//CreateFromWorker.StoreWhitespaceForToken(newItem, closeTypeParam, LanguagePart.Current, LanguageElement.TypeParameterEndDelimiter);
}
protected override IEnumerable <IDom> CreateListFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var list = new List <ITypeMember>();
//var fieldPublicAnnotations = CreateFromWorker.GetPublicAnnotations(syntaxNode, parent, model);
var rawField = syntaxNode as FieldDeclarationSyntax;
var declarators = rawField.Declaration.Variables.OfType <VariableDeclaratorSyntax>();
foreach (var decl in declarators)
{
var newItem = new RDomField(decl, parent, model);
list.Add(newItem);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.StoreWhitespace(newItem, syntaxNode, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, decl, LanguagePart.Current, WhitespaceLookup);
newItem.Name = newItem.TypedSymbol.Name;
if (decl.Initializer != null)
{
CreateFromWorker.StoreWhitespaceForToken(newItem, decl.Initializer.EqualsToken, LanguagePart.Current, LanguageElement.EqualsAssignmentOperator);
CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, decl.Initializer, LanguagePart.Current, LanguageElement.Expression);
newItem.Initializer = OutputContext.Corporation.CreateSpecial <IExpression>(decl.Initializer.Value, newItem, model).FirstOrDefault();
}
var returnType = OutputContext.Corporation
.Create(rawField.Declaration.Type, newItem, model)
.FirstOrDefault()
as IReferencedType;
newItem.ReturnType = returnType;
var fieldSymbol = newItem.Symbol as IFieldSymbol;
newItem.IsStatic = fieldSymbol.IsStatic;
newItem.IsVolatile = fieldSymbol.IsVolatile;
newItem.IsReadOnly = fieldSymbol.IsReadOnly;
newItem.IsConstant = fieldSymbol.HasConstantValue;
// See note on IsNew on interface before changing
newItem.IsNew = rawField.Modifiers.Any(x => x.Kind() == SyntaxKind.NewKeyword);
//newItem.PublicAnnotations.Add(fieldPublicAnnotations);
}
return(list);
}
private RDomIfStatement CreateCollapsing(IfStatementSyntax syntax, IDom parent, SemanticModel model)
{
// You can't use descendants here becuase it is a very specific pattern
var newItem = new RDomIfStatement(syntax, parent, model);
UpdateItem(newItem, syntax.Statement, syntax.Condition, syntax, parent, model);
var currentSyntax = syntax;
IElseBaseStatement lastItem = newItem;
while (currentSyntax != null)
{
if (currentSyntax.Else == null) // We're done
{
break;
}
var elseAsIf = currentSyntax.Else.Statement as IfStatementSyntax;
if (elseAsIf != null)
{
var newElse = new RDomElseIfStatement(elseAsIf, newItem, model);
UpdateItem(newElse, elseAsIf.Statement, elseAsIf.Condition, elseAsIf, newItem, model);
CreateFromWorker.StoreWhitespaceForToken(newElse, currentSyntax.Else.ElseKeyword,
LanguagePart.Current, LanguageElement.ElseKeyword);
newItem.Elses.AddOrMove(newElse);
lastItem = newElse;
currentSyntax = elseAsIf;
}
else // At terminus, add else and we're done
{
var newElse = new RDomElseStatement(currentSyntax.Else, newItem, model);
UpdateItem(newElse, currentSyntax.Else.Statement, null, currentSyntax.Else, newItem, model);
CreateFromWorker.StoreWhitespaceForToken(newElse, currentSyntax.Else.ElseKeyword,
LanguagePart.Current, LanguageElement.ElseKeyword);
newItem.Elses.AddOrMove(newElse);
break;
}
}
return(newItem);
}
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
// TODO: Why not cast immediately to BinaryExpression?
var syntax = syntaxNode as ExpressionStatementSyntax;
var newItem = new RDomAssignmentStatement(syntaxNode, parent, model);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, syntax.Expression, LanguagePart.Current, WhitespaceLookup);
var binary = syntax.Expression as AssignmentExpressionSyntax;
Guardian.Assert.IsNotNull(binary, nameof(binary));
var left = binary.Left as ExpressionSyntax;
CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, left, LanguagePart.Current,
LanguageElement.LeftExpression);
newItem.Left = OutputContext.Corporation.CreateSpecial <IExpression>(left, newItem, model).FirstOrDefault();
// Previously tested for identifier here, but can also be SimpleMemberAccess and ElementAccess expressions
// not currently seeing value in testing for the type. Fix #46
// Also changed Name to Left and string to expression
var right = binary.Right;
var expression = right as ExpressionSyntax;
CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, expression, LanguagePart.Current,
LanguageElement.Expression);
Guardian.Assert.IsNotNull(expression, nameof(expression));
newItem.Expression = OutputContext.Corporation.CreateSpecial <IExpression>(expression, newItem, model).FirstOrDefault();
CreateFromWorker.StoreWhitespaceForToken(newItem, binary.OperatorToken,
LanguagePart.Current, LanguageElement.AssignmentOperator);
newItem.Operator = Mappings.AssignmentOperatorFromCSharpKind(binary.CSharpKind());
return(newItem);
}
