private bool IsValueField(Field field)
{
return !IsNodeOrNodeList(field.Type);
}
private bool IsAutoCreatableNode(Node node, Field field)
{
var referencedNode = GetNode(field.Type);
return (referencedNode != null && RequiredFactoryArgumentCount(referencedNode) == 0);
}
private bool IsRequiredFactoryField(Node node, Field field)
{
return (!IsOptional(field) && !IsAnyList(field.Type) && !CanBeAutoCreated(node, field)) || IsValueField(field);
}
protected static string OverrideOrNewModifier(Field field)
{
return IsOverride(field) ? "override " : IsNew(field) ? "new " : "";
}
private bool IsAutoCreatableToken(Node node, Field field)
{
return field.Type == "SyntaxToken"
&& field.Kinds != null
&& ((field.Kinds.Count == 1 && field.Kinds[0].Name != "IdentifierToken" && !field.Kinds[0].Name.EndsWith("LiteralToken", StringComparison.Ordinal)) || (field.Kinds.Count > 1 && field.Kinds.Count == node.Kinds.Count));
}
private bool CanAutoConvertFromString(Field field)
{
return IsIdentifierToken(field) || IsIdentifierNameSyntax(field);
}
private bool IsIdentifierNameSyntax(Field field)
{
return field.Type == "IdentifierNameSyntax";
}
protected static bool IsNew(Field f)
{
return f.New != null && string.Compare(f.New, "true", true) == 0;
}
//guess a reasonable kind if there are no constraints
private static string ChooseValidKind(Field field)
{
return field.Kinds.Any() ? field.Kinds[0].Name : "IdentifierToken";
}
protected static bool IsOverride(Field f)
{
return f.Override != null && string.Compare(f.Override, "true", true) == 0;
}
protected static bool IsInternal(Field f)
{
return f.Internal != null && string.Compare(f.Internal, "true", true) == 0;
}
protected static string GetFieldType(Field field)
{
if (IsAnyList(field.Type))
return "CSharpSyntaxNode";
return field.Type;
}
protected static bool CanBeField(Field field)
{
return field.Type != "SyntaxToken" && !IsAnyList(field.Type) && !IsOverride(field) && !IsNew(field);
}
protected static string AccessibilityModifier(Field field)
{
return IsInternal(field) ? "internal" : "public";
}
private string GetRedPropertyType(Field field)
{
if (field.Type == "SyntaxList<SyntaxToken>")
return "SyntaxTokenList";
return field.Type;
}
private void WriteRedListHelperMethods(Node node, Field field)
{
var argType = GetElementType(field.Type);
WriteLine();
WriteLine(" public {0} Add{1}(params {2}[] items)", node.Name, field.Name, argType);
WriteLine(" {");
WriteLine(" return this.With{0}(this.{1}.AddRange(items));", StripPost(field.Name, "Opt"), field.Name);
WriteLine(" }");
}
private string GetDefaultValue(Node nd, Field field)
{
System.Diagnostics.Debug.Assert(!IsRequiredFactoryField(nd, field));
if (IsOptional(field) || IsAnyList(field.Type))
{
return string.Format("default({0})", GetRedPropertyType(field));
}
else if (field.Type == "SyntaxToken")
{
// auto construct token?
if (field.Kinds.Count == 1)
{
return string.Format("SyntaxFactory.Token(SyntaxKind.{0})", field.Kinds[0].Name);
}
else
{
return string.Format("SyntaxFactory.Token(Get{0}{1}Kind(kind))", StripPost(nd.Name, "Syntax"), StripPost(field.Name, "Opt"));
}
}
else
{
var referencedNode = GetNode(field.Type);
return string.Format("SyntaxFactory.{0}()", StripPost(referencedNode.Name, "Syntax"));
}
}
private void WriteRedNestedListHelperMethods(Node node, Field field, Node referencedNode, Field referencedNodeField)
{
var argType = GetElementType(referencedNodeField.Type);
// AddBaseListTypes
WriteLine();
WriteLine(" public {0} Add{1}{2}(params {3}[] items)", node.Name, StripPost(field.Name, "Opt"), referencedNodeField.Name, argType);
WriteLine(" {");
if (IsOptional(field))
{
var factoryName = StripPost(referencedNode.Name, "Syntax");
var varName = StripPost(CamelCase(field.Name), "Opt");
WriteLine(" var {0} = this.{1} ?? SyntaxFactory.{2}();", varName, field.Name, factoryName);
WriteLine(" return this.With{0}({1}.With{2}({1}.{3}.AddRange(items)));", StripPost(field.Name, "Opt"), varName, StripPost(referencedNodeField.Name, "Opt"), referencedNodeField.Name);
}
else
{
WriteLine(" return this.With{0}(this.{1}.With{2}(this.{1}.{3}.AddRange(items)));", StripPost(field.Name, "Opt"), field.Name, StripPost(referencedNodeField.Name, "Opt"), referencedNodeField.Name);
}
WriteLine(" }");
}
private bool IsIdentifierToken(Field field)
{
return field.Type == "SyntaxToken" && field.Kinds != null && field.Kinds.Count == 1 && field.Kinds[0].Name == "IdentifierToken";
}
protected bool CanBeAutoCreated(Node node, Field field)
{
return IsAutoCreatableToken(node, field) || IsAutoCreatableNode(node, field);
}
private string GetStringConverterMethod(Field field)
{
if (IsIdentifierToken(field))
{
return "SyntaxFactory.Identifier";
}
else if (IsIdentifierNameSyntax(field))
{
return "SyntaxFactory.IdentifierName";
}
else
{
throw new NotSupportedException();
}
}
protected static string GetFieldType(Field field, bool green)
{
if (IsAnyList(field.Type))
{
return green
? "GreenNode"
: "SyntaxNode";
}
return field.Type;
}
