public override SyntaxNode VisitStructureBlock(StructureBlockSyntax originalNode)
{
var node = (StructureBlockSyntax)base.VisitStructureBlock(originalNode);
var begin = (StructureStatementSyntax)EnsureVisibility(node.StructureStatement, node.StructureStatement.Modifiers, (x, l) => x.WithModifiers(l), () => GetTypeDefaultVisibility(originalNode));
return(node.WithStructureStatement(begin));
}
public override void VisitStructureBlock(StructureBlockSyntax node)
{
if (TryAddPublicApi(node.StructureStatement))
{
base.VisitStructureBlock(node);
}
}
internal static CodeStructureItem MapItem(StructureBlockSyntax node)
{
var item = CreateItem <StructNode>(node);
item.AccessModifier = node.StructureStatement.Modifiers.GetAccessModifier();
item.Name = node.StructureStatement.Identifier.Text;
return(item);
}
public override void VisitStructureBlock(StructureBlockSyntax node)
{
AddBlockData(node);
base.VisitStructureBlock(node);
}
public override void VisitStructureBlock(StructureBlockSyntax node)
{
}
public override void VisitStructureBlock(StructureBlockSyntax node)
{
var statementNode = node.ChildNodes().OfType <StructureStatementSyntax>().FirstOrDefault();
var isPartial = statementNode.ChildTokens().Any(x => x.Kind() == SyntaxKind.PartialKeyword);
var defineName = statementNode.ChildTokens().FirstOrDefault(x => x.Kind() == SyntaxKind.IdentifierToken).ToString();
// ジェネリック型を定義している場合
if (statementNode.ChildNodes().OfType <TypeParameterListSyntax>().Any())
{
var listNode = statementNode.ChildNodes().OfType <TypeParameterListSyntax>().FirstOrDefault();
var genericTypes = listNode
.ChildNodes()
.OfType <TypeParameterSyntax>()
.Select(x => x.ChildTokens().FirstOrDefault(y => y.Kind() == SyntaxKind.IdentifierToken).ToString());
defineName = $"{defineName}<{string.Join(", ", genericTypes)}>";
}
var startLength = node.Span.Start;
var endLength = node.Span.End;
var parentNamespace = GetNamespace(DefineKinds.Struct, startLength, endLength);
var baseTypeInfos = new List <BaseTypeInfo>();
// 継承元クラス、またはインターフェースがある場合
var hasInherits = node.ChildNodes().OfType <InheritsStatementSyntax>().Any();
var hasImplements = node.ChildNodes().OfType <ImplementsStatementSyntax>().Any();
if (hasInherits || hasImplements)
{
var baseTypes = new List <SyntaxNode>();
if (hasInherits)
{
var inheritsNode = node.ChildNodes().OfType <InheritsStatementSyntax>().FirstOrDefault();
var childNodes = inheritsNode.ChildNodes();
// Struct の場合、多重継承はできない仕様だが、将来仕様変更されるか？されないと思う
foreach (var childNode in childNodes)
{
baseTypes.Add(childNode);
}
}
if (hasImplements)
{
var implementsNode = node.ChildNodes().OfType <ImplementsStatementSyntax>().FirstOrDefault();
var childNodes = implementsNode.ChildNodes();
foreach (var childNode in childNodes)
{
baseTypes.Add(childNode);
}
}
baseTypeInfos = GetBaseTypeInfos(baseTypes, parentNamespace);
}
UserDefinitions.Add(new UserDefinition
{
DefineKinds = DefineKinds.Struct,
IsPartial = isPartial,
Namespace = parentNamespace,
DefineName = defineName,
DefineFullName = $"{parentNamespace}.{defineName}",
BaseTypeInfos = baseTypeInfos,
SourceFile = SourceFile,
StartLength = startLength,
EndLength = endLength,
});
base.VisitStructureBlock(node);
}
public override void VisitStructureBlock(StructureBlockSyntax node)
{
LogicalLineCount++;
base.VisitStructureBlock(node);
}
public override void VisitStructureBlock(StructureBlockSyntax node)
{
if (structureNameRegEx.Match(node.StructureStatement.Identifier.Text).Success)
{
StringBuilder messageFields = new StringBuilder();
Boolean displayStructure = AllFieldTypes;
if (ShowFields)
{
foreach (var field in node.DescendantNodes().OfType <FieldDeclarationSyntax>())
{
if (!fieldNameRegEx.Match(field.ToString()).Success)
{
continue;
}
Boolean addField = false;
var ac = field.ChildNodes().OfType <VariableDeclaratorSyntax>();
var ac2 = field.ChildNodes().OfType <VariableDeclaratorSyntax>().FirstOrDefault().AsClause;
var asClauseType = ac2.Type();
var ac4 = asClauseType.GetType() == typeof(Int32);
var ac5 = typeof(Int32);
var ac6 = ac5.ToString();
switch (asClauseType.ToString())
{
case "Boolean":
if (_configurationOptions.Boolean)
{
addField = true;
}
break;
case "Byte":
if (_configurationOptions.Byte)
{
addField = true;
}
break;
case "Date":
if (_configurationOptions.Date)
{
addField = true;
}
break;
case "DateTime":
if (_configurationOptions.DateTime)
{
addField = true;
}
break;
case "Int16":
if (_configurationOptions.Int16)
{
addField = true;
}
break;
case "Int32":
if (_configurationOptions.Int32)
{
addField = true;
}
break;
case "Int64":
if (_configurationOptions.Int64)
{
addField = true;
}
break;
case "Integer":
if (_configurationOptions.Integer)
{
addField = true;
}
break;
case "Long":
if (_configurationOptions.Long)
{
addField = true;
}
break;
case "Single":
if (_configurationOptions.Single)
{
addField = true;
}
break;
case "String":
if (_configurationOptions.String)
{
addField = true;
}
break;
default:
if (_configurationOptions.OtherTypes && !displayStructure)
{
addField = true;
}
break;
}
if (HasAttributes)
{
if (field.AttributeLists.Count > 0)
{
addField = true;
}
}
////if (IsOtherType && ! displayField)
////{
//// displayField = true;
////}
if (addField)
{
messageFields.AppendLine(string.Format(" {0}", field.ToString()));
displayStructure = true;
}
}
}
if (displayStructure)
{
//string messageContext = "";
//if (_configurationOptions.ClassOrModuleName)
//{
// messageContext = Helpers.VB.GetContainingContext(node, _configurationOptions);
//}
//if (_configurationOptions.MethodName)
//{
// messageContext += string.Format(" Method:({0, -35})", Helpers.VB.GetContainingMethod(node));
//}
//Messages.AppendLine(String.Format("{0} {1}",
// messageContext,
// node.StructureStatement.ToString()));
////Messages.AppendLine(node.StructureStatement.ToString());
RecordMatchAndContext(node, BlockType.None);
if (ShowFields)
{
Messages.AppendLine(messageFields.ToString());
}
}
}
// Call base to visit children
base.VisitStructureBlock(node);
}
private Struct TraverseStruct(StructureBlockSyntax sbs)
{
Struct retClass = new Struct();
retClass.Name = sbs.Begin.Identifier.ValueText;
//encapsulation
foreach (SyntaxToken st in sbs.Begin.Modifiers)
{
string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
Encapsulation encap;
Qualifiers qual;
if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
{
retClass.Encapsulation.Add(encap);
}
else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
{
retClass.Qualifiers.Add(qual);
}
}
List<EnumBlockSyntax> enums = new List<EnumBlockSyntax>();
List<StructureBlockSyntax> structs = new List<StructureBlockSyntax>();
List<MethodBlockSyntax> methods = new List<MethodBlockSyntax>();
List<FieldDeclarationSyntax> Fields = new List<FieldDeclarationSyntax>();
List<PropertyBlockSyntax> properties = new List<PropertyBlockSyntax>();
List<ConstructorBlockSyntax> constructors = new List<ConstructorBlockSyntax>();
List<ModuleBlockSyntax> modules = new List<ModuleBlockSyntax>();
List<ClassBlockSyntax> classes = new List<ClassBlockSyntax>();
foreach (SyntaxNode sn in sbs.ChildNodes())
{
if (sn is EnumBlockSyntax)
{
enums.Add(sn as EnumBlockSyntax);
}
else if (sn is StructureBlockSyntax)
{
structs.Add(sn as StructureBlockSyntax);
}
else if (sn is MethodBlockSyntax)
{
methods.Add(sn as MethodBlockSyntax);
}
else if (sn is FieldDeclarationSyntax)
{
Fields.Add(sn as FieldDeclarationSyntax);
}
else if (sn is PropertyBlockSyntax)
{
properties.Add(sn as PropertyBlockSyntax);
}
else if (sn is ConstructorBlockSyntax)
{
constructors.Add(sn as ConstructorBlockSyntax);
}
else if (sn is ModuleBlockSyntax)
{
modules.Add(sn as ModuleBlockSyntax);
}
else if (sn is ClassBlockSyntax)
{
classes.Add(sn as ClassBlockSyntax);
}
}
foreach (EnumBlockSyntax ebs in enums)
{
//traverse enums
retClass.Enums.Add(TraverseEnum(ebs));
}
foreach (StructureBlockSyntax sbs2 in structs)
{
retClass.Structs.Add(TraverseStruct(sbs2));
}
foreach (MethodBlockSyntax mbs in methods)
{
bool isConstructor = false;
Method tempMethod = TraverseMethod(mbs, ref isConstructor);
if (isConstructor)
{
retClass.Constructors.Add(tempMethod as Constructor);
}
else
{
retClass.Methods.Add(tempMethod);
}
}
foreach (FieldDeclarationSyntax fds in Fields)
{
retClass.Fields.Add(TraverseField(fds));
}
foreach (PropertyBlockSyntax pbs in properties)
{
retClass.Properties.Add(TraverseProperties(pbs));
}
foreach (ConstructorBlockSyntax css in constructors)
{
retClass.Constructors.Add(TraverseConstructor(css));
}
foreach (ModuleBlockSyntax mbs in modules)
{
retClass.Modules.Add(TraverseModule(mbs));
}
foreach (ClassBlockSyntax sbs2 in classes)
{
retClass.Classes.Add(TraverseClass(sbs2));
}
foreach (SyntaxNode sn in sbs.Begin.ChildNodes())
{
if (sn is InheritsOrImplementsStatementSyntax)
{
}
}
return retClass;
}
