| public GetVariableTypeSyntax ( bool isImplicitlyTyped, IReferencedType type ) : Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax | ||
| isImplicitlyTyped | bool | |
| type | IReferencedType | |
| return | Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax | |
protected override ForStatementSyntax MakeSyntax(RDomForStatement itemAsT, ExpressionSyntax condition, StatementSyntax statementBlock)
{
var declaratorSyntax = (VariableDeclaratorSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.Variable);
var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(
itemAsT.Variable.IsImplicitlyTyped, itemAsT.Variable.Type);
//var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.Variable);
var nodeDeclaratorInList = SyntaxFactory.SeparatedList(SyntaxFactory.List <VariableDeclaratorSyntax>(new VariableDeclaratorSyntax[] { declaratorSyntax }));
var nodeDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax, nodeDeclaratorInList);
nodeDeclaration = BuildSyntaxHelpers.AttachWhitespace(nodeDeclaration, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Variable);
var incrementorSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Incrementor);
incrementorSyntax = BuildSyntaxHelpers.AttachWhitespace(incrementorSyntax, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Iterator);
var secondSemiColonToken = SyntaxFactory.Token(SyntaxKind.SemicolonToken);
secondSemiColonToken = triviaManager.AttachWhitespaceToToken(secondSemiColonToken, itemAsT.Whitespace2Set[LanguagePart.Condition, LanguageElement.EndOfLine]);
var node = SyntaxFactory.ForStatement(statementBlock)
.WithCondition(condition)
.WithDeclaration(nodeDeclaration)
.WithIncrementors(SyntaxFactory.SeparatedList <ExpressionSyntax>(new ExpressionSyntax[] { (ExpressionSyntax)incrementorSyntax }))
.WithSecondSemicolonToken(secondSemiColonToken);
return(node);
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IDeclarationStatement;
var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name);
var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.IsImplicitlyTyped, itemAsT.Type);
var variable = item as IVariableDeclaration;
// This is a weakness in the current factory lookup - we can't just ask for a random factory
// so to call the normal build syntax through the factory causes infinite recursion.
// TODO: Add the ability to request a random factory from the container (via the CSharp uber factory
var tempFactory = new RDomVariableDeclarationFactory(OutputContext.Corporation);
var nodeDeclarators = tempFactory.BuildSyntax(item);
var nodeDeclarator = (VariableDeclaratorSyntax)nodeDeclarators.First();
var nodeDeclaratorInList = SyntaxFactory.SeparatedList(
SyntaxFactory.List <VariableDeclaratorSyntax>(
new VariableDeclaratorSyntax[]
{ nodeDeclarator }));
var nodeDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax, nodeDeclaratorInList);
nodeDeclaration = BuildSyntaxHelpers.AttachWhitespace(nodeDeclaration, itemAsT.Whitespace2Set, WhitespaceLookup);
var node = SyntaxFactory.LocalDeclarationStatement(nodeDeclaration);
if (itemAsT.IsConst)
{
node = node.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ConstKeyword)));
}
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IUsingStatement;
var statement = RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup);
var node = SyntaxFactory.UsingStatement(statement);
if (itemAsT.Variable != null)
{
//var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.Variable);
var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(
itemAsT.Variable.IsImplicitlyTyped, itemAsT.Variable.Type);
var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Variable.Initializer);
var equalsValueClause = SyntaxFactory.EqualsValueClause((ExpressionSyntax)expressionSyntax);
equalsValueClause = BuildSyntaxHelpers.AttachWhitespace(equalsValueClause, itemAsT.Variable.Whitespace2Set, WhitespaceLookup);
var nodeDeclarator = SyntaxFactory.VariableDeclarator(itemAsT.Variable.Name);
nodeDeclarator = nodeDeclarator.WithInitializer(equalsValueClause);
nodeDeclarator = BuildSyntaxHelpers.AttachWhitespace(nodeDeclarator, itemAsT.Variable.Whitespace2Set, WhitespaceLookup);
var nodeDeclaratorInList = SyntaxFactory.SeparatedList(SyntaxFactory.List <VariableDeclaratorSyntax>(new VariableDeclaratorSyntax[] { (VariableDeclaratorSyntax)nodeDeclarator }));
var nodeDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax, nodeDeclaratorInList);
node = node.WithDeclaration(nodeDeclaration);
}
else
{
var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Expression) as ExpressionSyntax;
node = node.WithExpression(expressionSyntax);
}
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
protected override ForEachStatementSyntax MakeSyntax(
RDomForEachStatement itemAsT, ExpressionSyntax condition, StatementSyntax statementBlock)
{
var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(
itemAsT.Variable.IsImplicitlyTyped, itemAsT.Variable.Type);
//var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.Variable);
//typeSyntax = BuildSyntaxHelpers.AttachWhitespace(typeSyntax, itemAsT.Whitespace2Set, WhitespaceLookup);
var id = itemAsT.Variable.Name;
return(SyntaxFactory.ForEachStatement(typeSyntax, id, condition, statementBlock));
}
