protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var syntax = syntaxNode as OperatorDeclarationSyntax;
var newItem = new RDomOperator(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.Body, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, syntax.ParameterList, LanguagePart.Current, WhitespaceLookup);
newItem.Name = newItem.TypedSymbol.Name;
var returnType = OutputContext.Corporation
.Create(syntax.ReturnType, newItem, model)
.FirstOrDefault()
as IReferencedType;
newItem.Type = returnType;
newItem.Operator = Mappings.OperatorFromCSharpKind(syntax.OperatorToken.Kind());
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);
return(newItem);
}
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 TryStatementSyntax;
var newItem = new RDomTryStatement(syntaxNode, parent, model);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.InitializeStatements(newItem, syntax.Block, newItem, model);
CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, syntax.Block, LanguagePart.Current, WhitespaceLookup);
var catchSyntaxList = syntax.ChildNodes()
.Where(x => x.CSharpKind() == SyntaxKind.CatchClause)
.OfType <CatchClauseSyntax>();
foreach (var ctch in catchSyntaxList)
{
var newCatch = new RDomCatchStatement(ctch, newItem, model);
CreateFromWorker.StandardInitialize(newCatch, ctch, newItem, model, OutputContext);
CreateFromWorker.InitializeStatements(newCatch, ctch.Block, newCatch, model);
CreateFromWorker.StoreWhitespace(newCatch, ctch, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newCatch, ctch.Block, LanguagePart.Current, WhitespaceLookup);
if (ctch.Declaration != null)
{
var type = OutputContext.Corporation
.Create(ctch.Declaration.Type, newCatch, model)
.FirstOrDefault()
as IReferencedType;
newCatch.ExceptionType = type;
CreateFromWorker.StoreWhitespace(newCatch, ctch.Declaration, LanguagePart.Current, WhitespaceLookup);
if (!string.IsNullOrWhiteSpace(ctch.Declaration.Identifier.ToString()))
{
newCatch.Variable = OutputContext.Corporation.Create(ctch.Declaration, newCatch, model).FirstOrDefault() as IVariableDeclaration;
newCatch.Variable.Type = type;
}
}
if (ctch.Filter != null)
{
newCatch.Condition = OutputContext.Corporation.CreateSpecial <IExpression>(ctch.Filter.FilterExpression, newCatch, model).FirstOrDefault();
CreateFromWorker.StoreWhitespace(newCatch.Condition, ctch.Filter, LanguagePart.Current, WhitespaceLookup);
}
newItem.CatchesAll.AddOrMove(newCatch);
}
if (syntax.Finally != null)
{
var newFinally = new RDomFinallyStatement(syntax.Finally, newItem, model);
CreateFromWorker.StandardInitialize(newFinally, syntax.Finally, parent, model, OutputContext);
CreateFromWorker.InitializeStatements(newFinally, syntax.Finally.Block, newFinally, model);
CreateFromWorker.StoreWhitespace(newFinally, syntax.Finally, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newFinally, syntax.Finally.Block, LanguagePart.Current, WhitespaceLookup);
newItem.Finally = newFinally;
}
return(newItem);
}
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var syntax = syntaxNode as DestructorDeclarationSyntax;
var newItem = new RDomDestructor(syntaxNode, parent, model);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.InitializeStatements(newItem, syntax.Body, newItem, model);
CreateFromWorker.StoreWhitespace(newItem, syntaxNode, LanguagePart.Current, WhitespaceLookup);
newItem.Name = newItem.TypedSymbol.Name;
return(newItem);
}
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var syntax = syntaxNode as CheckedStatementSyntax;
var newItem = new RDomCheckedStatement(syntaxNode, parent, model);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.InitializeStatements(newItem, syntax.Block, newItem, model);
CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, syntax.Block, LanguagePart.Current, WhitespaceLookup);
newItem.Unchecked = (syntax.CSharpKind() == SyntaxKind.UncheckedStatement);
return(newItem);
}
private void UpdateItem <T>(T newItem, StatementSyntax statement, ExpressionSyntax condition,
SyntaxNode syntax, IDom parent, SemanticModel model)
where T : class, IDom, IStatementBlock
{
CreateFromWorker.StandardInitialize(newItem, syntax, parent, model, OutputContext);
CreateFromWorker.InitializeStatements(newItem, statement, newItem, model);
CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, statement, LanguagePart.Current, WhitespaceLookup);
var itemAsHasCondition = newItem as IHasCondition;
if (itemAsHasCondition != null)
{
itemAsHasCondition.Condition = OutputContext.Corporation.CreateSpecial <IExpression>(condition, newItem, model).FirstOrDefault();
CreateFromWorker.StoreWhitespace(itemAsHasCondition, condition, LanguagePart.Current, WhitespaceLookup);
}
}
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var syntax = syntaxNode as LockStatementSyntax;
var newItem = new RDomLockStatement(syntaxNode, parent, model);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.InitializeStatements(newItem, syntax.Statement, newItem, model);
CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, syntax.Statement, LanguagePart.Current, WhitespaceLookup);
var expr = OutputContext.Corporation.CreateSpecial <IExpression>(syntax.Expression, newItem, model).FirstOrDefault();
CreateFromWorker.StoreWhitespace(expr, syntax.Expression, LanguagePart.Current, WhitespaceLookup);
newItem.Expression = expr;
return(newItem);
}
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;
}
newItem.InitializationArguments.CreateAndAdd(syntax, x => x.Initializer.ArgumentList.Arguments, x => OutputContext.Corporation.Create(x, newItem, model).Cast <IArgument>());
CreateFromWorker.StoreWhitespace(newItem, initializerSyntax.ArgumentList, LanguagePart.Initializer, WhitespaceLookup);
}
return(newItem);
}
private ILambdaExpression CreateItemFromInternal(CSharpSyntaxNode body, SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var block = body as BlockSyntax;
if (block != null)
{
var newItem = new RDomLambdaMultiLineExpression(syntaxNode, parent, model);
CreateFromWorker.InitializeStatements(newItem, block, newItem, model);
return(newItem);
}
else
{
var exp = body as IExpression;
var newItem = new RDomLambdaSingleExpression(syntaxNode, parent, model);
newItem.Expression = exp;
return(newItem);
}
}
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var syntax = syntaxNode as UsingStatementSyntax;
var newItem = new RDomUsingStatement(syntaxNode, parent, model);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.InitializeStatements(newItem, syntax.Statement, newItem, model);
CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, syntax.Statement, LanguagePart.Current, WhitespaceLookup);
// if there is both a declaration and an expression, I'm terribly confused
var declaration = syntax.Declaration;
var expression = syntax.Expression;
if (declaration != null && expression != null)
{
throw new InvalidOperationException();
}
if (declaration == null && expression == null)
{
throw new InvalidOperationException();
}
var statement = syntax.Statement;
if (declaration != null)
{
// Not yet, and might never support as Kendall Miller said "huh, that works?" on Twitter
if (declaration.Variables.Count() > 1)
{
throw new NotImplementedException();
}
var newVariable = OutputContext.Corporation.Create(syntax.Declaration, newItem, model).FirstOrDefault();
newItem.Variable = (IVariableDeclaration)newVariable;
}
else
{
var expr = OutputContext.Corporation.CreateSpecial <IExpression>(syntax.Expression, newItem, model).FirstOrDefault();
CreateFromWorker.StoreWhitespace(expr, syntax.Expression, LanguagePart.Current, WhitespaceLookup);
newItem.Expression = expr;
}
return(newItem);
}
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var syntax = syntaxNode as AccessorDeclarationSyntax;
var parentProperty = parent as IProperty;
var accessorType = (syntaxNode.Kind() == SyntaxKind.GetAccessorDeclaration)
? AccessorType.Get : AccessorType.Set;
var newItem = new RDomPropertyAccessor(syntaxNode, accessorType, parent, model);
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.InitializeStatements(newItem, syntax.Body, newItem, model);
CreateFromWorker.StoreWhitespace(newItem, syntaxNode, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, syntax.Body, LanguagePart.Current, WhitespaceLookup);
var newItemName = accessorType.ToString().ToLower() + "_" + parentProperty.Name;
newItem.Name = newItemName;
return(newItem);
}
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
var syntax = syntaxNode as TSyntax;
var newItem = MakeNewItem(syntax, parent, model);
var condition = GetConditionFromSyntax(syntax);
var statement = GetStatementFromSyntax(syntax);
var conditionObj = OutputContext.Corporation.CreateSpecial <IExpression>(condition, newItem, model).FirstOrDefault();
newItem.Condition = conditionObj as IExpression;
CreateFromWorker.InitializeStatements(newItem, statement, newItem, model);
Guardian.Assert.IsNotNull(condition, nameof(condition));
CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext);
CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, statement, LanguagePart.Current, WhitespaceLookup);
CreateFromWorker.StoreWhitespace(newItem, condition, LanguagePart.Current, WhitespaceLookup);
return(newItem);
}
