private static SyntaxNode Method(SyntaxNode node, Scope scope)
{
if (!(node is MethodDeclarationSyntax))
{
//td: error
return(node);
}
var method = node as MethodDeclarationSyntax;
if (!RoslynCompiler.HasVisibilityModifier(method.Modifiers))
{
method = method.AddModifiers(CSharp.Token(SyntaxKind.PublicKeyword));
}
if (method.ReturnType.IsMissing)
{
var document = scope.GetDocument <SyntaxToken, SyntaxNode, SemanticModel>();
document.change(method, FixReturnType);
return(method.WithReturnType(RoslynCompiler.@void));
}
return(method);
}
private static TypeDeclarationSyntax ParseModel(ClassDeclarationSyntax @class, ParameterListSyntax parameters, Scope scope)
{
var init = new List <ParameterSyntax>();
var props = new List <PropertyDeclarationSyntax>();
foreach (var member in @class.Members)
{
var field = ParseField(member);
if (field == null)
{
continue; //error has already been registered
}
var type = field.Declaration.Type;
var variable = field.Declaration
.Variables
.Single();
init.Add(CSharp.Parameter(variable.Identifier)
.WithType(type)
.WithDefault(CSharp.EqualsValueClause(
variable.Initializer != null
? variable.Initializer.Value
: CSharp.DefaultExpression(type))));
props.Add(ModelProperty.Get <PropertyDeclarationSyntax>(type)
.WithIdentifier(variable.Identifier));
}
if (!RoslynCompiler.HasVisibilityModifier(@class.Modifiers))
{
@class = @class.AddModifiers(CSharp.Token(SyntaxKind.PublicKeyword));
}
return(@class
.WithMembers(CSharp.List <MemberDeclarationSyntax>(
props.Union(new[] {
GenerateConstructor(@class, init)
}))));
}
private static SyntaxNode Property(SyntaxNode node, Scope scope)
{
var field = node.AncestorsAndSelf()
.OfType <MemberDeclarationSyntax>()
.FirstOrDefault()
as FieldDeclarationSyntax;
if (field == null)
{
//td: error, malformed property
return(node);
}
if (field.Declaration.Variables.Count != 1)
{
//td: error, malformed property
return(node);
}
var variable = field
.Declaration
.Variables[0];
var initializer = variable.Initializer;
var type = field.Declaration.Type;
if (type == null || type.IsMissing || type.ToString() == "property") //untyped
{
if (initializer != null)
{
type = RoslynCompiler.ConstantType(initializer.Value);
}
}
if (type == null)
{
type = RoslynCompiler.@object;
}
var property = _property
.WithIdentifier(variable.Identifier)
.WithType(type);
if (!RoslynCompiler.HasVisibilityModifier(field.Modifiers))
{
property = property.AddModifiers(CSharp.Token(SyntaxKind.PublicKeyword));
}
var document = scope.GetDocument <SyntaxToken, SyntaxNode, SemanticModel>();
//schedule the field replacement
//td: coud be done in this pass with the right info from lexical
document.change(field, RoslynCompiler.ReplaceNode(property));
//must be initialized
if (initializer != null)
{
var expr = (AssignmentExpressionSyntax)_assignment.Expression;
document.change(field.Parent, RoslynCompiler
.AddInitializers(_assignment.WithExpression(expr
.WithLeft(CSharp.IdentifierName(variable.Identifier))
.WithRight(initializer.Value))));
}
return(node);
}
