protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var syntax = syntaxNode as ConstructorDeclarationSyntax;
var newItem = new RDomConstructor(syntaxNode, parent, model);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.InitializeStatements(newItem, syntax.Body, newItem, model);
CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, syntax.Initializer, LanguagePart.Initializer, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, syntax.Body, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, syntax.ParameterList, LanguagePart.Current, WhitespaceLookup);
newItem.Name = newItem.TypedSymbol.Name;
//newItem.AccessModifier = RoslynUtilities.GetAccessibilityFromSymbol(newItem.Symbol);
//newItem.IsStatic = newItem.Symbol.IsStatic;
newItem.Parameters.CreateAndAdd(syntax, x => x.ParameterList.Parameters, x => OutputContext.Corporation.Create(x, newItem, model).Cast <IParameter>());
//var parameters = ListUtilities.MakeList(syntax, x => x.ParameterList.Parameters, x => Corporation.Create(x, newItem, model))
// .OfType<IParameter>();
//newItem.Parameters.AddOrMoveRange(parameters);
if (syntax.Initializer == null)
{
newItem.ConstructorInitializerType = ConstructorInitializerType.None;
}
else
{
var initializerSyntax = syntax.Initializer;
if (initializerSyntax.ThisOrBaseKeyword.ToString() == "this")
{
newItem.ConstructorInitializerType = ConstructorInitializerType.This;
}
else
{
newItem.ConstructorInitializerType = ConstructorInitializerType.Base;
}
CreateFromWorker.StoreWhitespace(newItem, initializerSyntax.ArgumentList,
LanguagePart.Initializer, WhitespaceLookup);
foreach (var arg in initializerSyntax.ArgumentList.Arguments)
{
var newArg = new RDomArgument(arg, newItem, model);
// TODO: Named paramters and align this with the invocation factory
newArg.ValueExpression = OutputContext.Corporation.CreateSpecial <IExpression>(arg.Expression, newItem, model).FirstOrDefault();
CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newArg, arg, LanguagePart.Current, LanguageElement.ConstructorInitializerArgument);
CreateFromWorker.StoreListMemberWhitespace(arg,
SyntaxKind.CommaToken, LanguageElement.ConstructorInitializerArgument, newArg);
newItem.InitializationArguments.AddOrMove(newArg);
}
}
return(newItem);
}
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var syntax = syntaxNode as ExpressionStatementSyntax;
var newItem = new RDomInvocationStatement(syntaxNode, parent, model);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, syntax, LanguagePart.Current,
LanguageElement.Expression);
var expression = syntax.Expression;
//newItem.Invocation = (IInvocationExpression)OutputContext.Corporation.Create<IExpression>(expression, newItem, model).FirstOrDefault();
newItem.Invocation = OutputContext.Corporation.Create(expression, newItem, model).FirstOrDefault() as IInvocationExpression;
return(newItem);
}
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);
}
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var syntax = syntaxNode as ArgumentSyntax;
var newItem = new RDomArgument(syntax, parent, model);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
newItem.ValueExpression = OutputContext.Corporation.CreateSpecial <IExpression>(syntax.Expression, newItem, model).FirstOrDefault();
newItem.IsOut = syntax.ChildTokens().Any(x => x.Kind() == SyntaxKind.OutKeyword);
newItem.IsRef = syntax.ChildTokens().Any(x => x.Kind() == SyntaxKind.RefKeyword);
if (syntax.NameColon != null)
{
newItem.Name = syntax.NameColon.Name.ToString();
}
CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, syntax, LanguagePart.Current, LanguageElement.OutModifier);
CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, syntax, LanguagePart.Current, LanguageElement.RefModifier);
MemberWhitespace(newItem, syntax);
return(newItem);
}
private void StoreConstructorConstraint(ConstructorConstraintSyntax syntax,
RDomTypeParameter newItem)
{
newItem.HasConstructorConstraint = true;
CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, syntax, LanguagePart.Current, LanguageElement.ConstructorConstraint);
CreateFromWorker.StoreListMemberWhitespace(syntax,
SyntaxKind.CommaToken, LanguageElement.ConstructorConstraint, newItem);
//var whitespace2 = newItem.Whitespace2Set[LanguageElement.ConstructorConstraint];
//if (string.IsNullOrEmpty(whitespace2.LeadingWhitespace))
//{
// var prevNodeOrToken = syntax.Parent
// .ChildNodesAndTokens()
// .PreviousSiblings(syntax)
// .LastOrDefault();
// var sepKind = SyntaxKind.CommaToken;
// if (prevNodeOrToken.Kind() == sepKind)
// {
// var commaToken = prevNodeOrToken.AsToken();
// whitespace2.LeadingWhitespace = commaToken.TrailingTrivia.ToString();
// }
//}
}
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);
}
