private RDomParameter CreateParameter(List <IAssignmentStatement> assignments, List <Tuple <RDomParameter, RDomParameter, RDomArgument> > altConstructorPairs, IProperty prop)
{
var paramName = StringUtilities.CamelCase(prop.Name);
var type = prop.PropertyType.Copy();
var param = new RDomParameter(paramName, type);
triviaManager.StoreStringWhitespace(param, LanguageElement.Identifier, " ", "");
triviaManager.StoreStringWhitespace(param, LanguageElement.EndOfLine, "", "\r\n");
var newAssignment = new RDomAssignmentStatement(
RDom.CSharp.ParseExpression(prop.Name),
RDom.CSharp.ParseExpression(paramName));
triviaManager.StoreStringWhitespace(newAssignment, LanguageElement.EndOfLine, "", "\r\n");
assignments.Add(newAssignment);
if (!(prop.Attributes.Any(x => x.Name == "Required")))
{
param.DefaultValue = GetDefaultValue(prop.PropertyType);
}
if (prop.PropertyType.Name == "IReferencedType")
{
var paramNewName = paramName + "Name";
var paramNew = new RDomParameter(paramName, "System.String");
var argNew = new RDomArgument(RDom.CSharp.ParseExpression(string.Format("new RDomReferencedType({0})", paramNewName)));
altConstructorPairs.Add(Tuple.Create(param, paramNew, argNew));
}
return(param);
}
private static RDomConstructor CreateRDomConstructor(IClass cl)
{
var constructor = new RDomConstructor(cl.Name, AccessModifier.Public, constructorInitializerType: ConstructorInitializerType.This);
var nullParam = new RDomArgument(RDom.CSharp.ParseExpression("null"));
constructor.InitializationArguments.AddOrMoveRange(new IArgument[] { nullParam, nullParam.Copy(), nullParam.Copy() });
cl.InsertAfterInitialFields(constructor);
return constructor;
}
private static RDomConstructor CreateRDomConstructor(IClass cl)
{
var constructor = new RDomConstructor(cl.Name, AccessModifier.Public, constructorInitializerType: ConstructorInitializerType.This);
var nullParam = new RDomArgument(RDom.CSharp.ParseExpression("null"));
constructor.InitializationArguments.AddOrMoveRange(new IArgument[] { nullParam, nullParam.Copy(), nullParam.Copy() });
cl.InsertAfterInitialFields(constructor);
return(constructor);
}
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);
}
public void Argument_can_be_constructed()
{
var expected = 42;
var expression = new RDomLiteralExpression(expected);
var arg = new RDomArgument(expression);
Assert.IsNotNull(expression);
Assert.IsNotNull(arg);
var actual = RDom.CSharp.GetSyntaxNode(arg).ToFullString();
Assert.AreEqual(expected.ToString(), actual);
}
public void Invocation_expression_can_be_constructed()
{
var root = RDom.CSharp.Load(csharpCode);
var method = root.Classes.First().Methods.First();
var expected = "Console.WriteLine(42)";
var expression = new RDomInvocationExpression("Console.WriteLine");
var arg = new RDomArgument(new RDomLiteralExpression(42));
expression.Arguments.AddOrMove(arg);
Assert.IsNotNull(expression);
var actual = RDom.CSharp.GetFormattedSourceCode(expression);
Assert.AreEqual(expected, actual);
}
public void Argument_can_be_constructed()
{
var expected = 42;
var expression = new RDomLiteralExpression(expected);
var arg = new RDomArgument(expression);
Assert.IsNotNull(expression);
Assert.IsNotNull(arg);
var actual = RDom.CSharp.GetSyntaxNode(arg).ToFullString();
Assert.AreEqual(expected.ToString(), actual);
}
public void Invocation_expression_can_be_constructed()
{
var root = RDom.CSharp.Load(csharpCode);
var method = root.Classes.First().Methods.First();
var expected = "Console.WriteLine(42)";
var expression = new RDomInvocationExpression("Console.WriteLine");
var arg = new RDomArgument(new RDomLiteralExpression(42));
expression.Arguments.AddOrMove(arg);
Assert.IsNotNull(expression);
var actual = RDom.CSharp.GetFormattedSourceCode(expression);
Assert.AreEqual(expected, actual);
}
private IEnumerable <IArgument> GetArguments(ArgumentListSyntax argumentList, IDom newItem, SemanticModel model)
{
var ret = new List <IArgument>();
foreach (var argSyntax in argumentList.Arguments)
{
// TODO: more work, align with constructor args, and probably create factory
var newArg = new RDomArgument(argSyntax, newItem, model);
// KAD: Explict node removal
//newArg.ValueExpression = OutputContext.Corporation.Create<IExpression>(argSyntax.Expression, newItem, model).FirstOrDefault();
newArg.ValueExpression = OutputContext.Corporation.CreateSpecial <IExpression>(argSyntax.Expression, newItem, model).FirstOrDefault();
if (argSyntax.NameColon != null)
{
newArg.Name = argSyntax.NameColon.Name.ToString();
}
newArg.IsRef = argSyntax.RefOrOutKeyword.CSharpKind() == SyntaxKind.RefKeyword;
newArg.IsOut = argSyntax.RefOrOutKeyword.CSharpKind() == SyntaxKind.OutKeyword;
ret.Add(newArg);
}
return(ret);
}
private RDomParameter CreateParameter(List<IAssignmentStatement> assignments, List<Tuple<RDomParameter, RDomParameter, RDomArgument>> altConstructorPairs, IProperty prop)
{
var paramName = StringUtilities.CamelCase(prop.Name);
var type = prop.PropertyType.Copy();
var param = new RDomParameter(paramName, type);
triviaManager.StoreStringWhitespace(param, LanguageElement.Identifier, " ", "");
triviaManager.StoreStringWhitespace(param, LanguageElement.EndOfLine, "", "\r\n");
var newAssignment = new RDomAssignmentStatement(
RDom.CSharp.ParseExpression(prop.Name),
RDom.CSharp.ParseExpression(paramName));
triviaManager.StoreStringWhitespace(newAssignment, LanguageElement.EndOfLine, "", "\r\n");
assignments.Add(newAssignment);
if (!(prop.Attributes.Any(x => x.Name == "Required")))
{
param.DefaultValue = GetDefaultValue(prop.PropertyType);
}
if (prop.PropertyType.Name == "IReferencedType")
{
var paramNewName = paramName + "Name";
var paramNew = new RDomParameter(paramName, "System.String");
var argNew = new RDomArgument(RDom.CSharp.ParseExpression(string.Format("new RDomReferencedType({0})", paramNewName)));
altConstructorPairs.Add(Tuple.Create(param, paramNew, argNew));
}
return param;
}
