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);
}
private static SyntaxNode SemanticEventHandler(SyntaxNode oldNode, SyntaxNode node, SemanticModel model, Scope scope)
{
var mthd = (MethodDeclarationSyntax)node;
var methdArgs = mthd.ParameterList;
var methodName = "on_" + mthd.Identifier.ToString();
ISymbol self = model.GetDeclaredSymbol(oldNode);
ITypeSymbol type = (ITypeSymbol)self.ContainingSymbol;
string evName = mthd.Identifier.ToString();
string typeName = type.Name;
bool found = false;
while (type != null && !found)
{
foreach (var ev in type.GetMembers().OfType <IEventSymbol>())
{
if (ev.Name.Equals(evName))
{
//arguments
foreach (var syntax in ev.Type.DeclaringSyntaxReferences)
{
var refNode = (DelegateDeclarationSyntax)syntax.GetSyntax();
int pCount = methdArgs.Parameters.Count;
int idx = 0;
bool match = true;
methdArgs = refNode.ParameterList.ReplaceNodes(refNode.ParameterList.Parameters, (oldArg, newArg) =>
{
if (match)
{
if (idx >= pCount && match)
{
return(newArg);
}
ParameterSyntax arg = methdArgs.Parameters[idx++];
string argName = arg.Identifier.ToString();
if (argName == oldArg.Identifier.ToString())
{
//coincident parameters, fix missing type or return same
if (arg.Identifier.IsMissing || arg.Type.ToString() == "void")
{
return(newArg.WithIdentifier(arg.Identifier));
}
return(arg);
}
else
{
match = false;
if (!refNode.ParameterList.Parameters.Any(p => p.Identifier.ToString().Equals(arg.Identifier.ToString())))
{
//name change?
if (oldArg.Identifier.IsMissing)
{
return(newArg.WithIdentifier(CSharp.Identifier(arg.Type.ToString())));
}
return(arg);
}
}
}
return(newArg);
});
}
//event initialization
var document = scope.GetDocument <SyntaxToken, SyntaxNode, SemanticModel>();
document.change(mthd.Parent, RoslynCompiler.AddInitializers(EventInitializer(ev.Name, methodName)));
found = true;
break;
}
}
type = type.BaseType;
}
if (!found)
{
//td: error, no such event
}
return(mthd.WithIdentifier(CSharp.Identifier(methodName)).
WithParameterList(methdArgs));
}
