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);
 }