public override void VisitImportsStatement(ImportsStatementSyntax node)
{
if (node.DescendantNodes().Any(x => x is ImportAliasClauseSyntax))
{
var simpleNode = node.ChildNodes().FirstOrDefault(x => x is SimpleImportsClauseSyntax);
var ns = simpleNode.ChildNodes().LastOrDefault().ToString();
var aliasNode = simpleNode.ChildNodes().FirstOrDefault(x => x is ImportAliasClauseSyntax);
var alternate = aliasNode.ChildTokens().FirstOrDefault(x => x.Kind() == SyntaxKind.IdentifierToken).ToString();
ImportsNamespaces.Add(new NamespaceInfo
{
Namespace = ns,
Alternate = alternate,
});
}
else
{
var ns = node.ChildNodes().FirstOrDefault().ToString();
ImportsNamespaces.Add(new NamespaceInfo
{
Namespace = ns,
Alternate = string.Empty,
});
}
base.VisitImportsStatement(node);
}
private List <BaseTypeInfo> GetBaseTypeInfos(IEnumerable <SyntaxNode> baseTypes, string defaultNamespace)
{
var candidatesNamespaces = new List <string>();
candidatesNamespaces.Add(defaultNamespace);
while (defaultNamespace.Contains("."))
{
defaultNamespace = defaultNamespace.Substring(0, defaultNamespace.LastIndexOf("."));
candidatesNamespaces.Add(defaultNamespace);
}
var firstImportsIndex = -1;
if (ImportsNamespaces.Any())
{
var results = ImportsNamespaces.Select(x => x.Namespace).ToList();
candidatesNamespaces.AddRange(results);
firstImportsIndex = candidatesNamespaces.IndexOf(results.FirstOrDefault());
}
var items = new List <BaseTypeInfo>();
foreach (var baseType in baseTypes)
{
var hasGlobal = false;
var typeName = baseType.ToString();
typeName = ConvertCSharpTypeWithoutRemoveNamespace(typeName);
if (ImportsNamespaces.Any())
{
foreach (var check in ImportsNamespaces)
{
if (!string.IsNullOrEmpty(check.Alternate) && typeName.Contains($"{check.Alternate}"))
{
typeName = typeName.Replace(check.Alternate, check.Namespace);
}
// 名前空間エイリアス修飾子（::演算子）の場合、:: が残る場合は . に置換
// ※ VBNet では :: は仕様的に無く . になるみたい
if (typeName.Contains("Global."))
{
hasGlobal = true;
typeName = typeName.Replace("Global.", string.Empty);
}
}
}
var candidatesDefineFullNames = new List <string>();
if (firstImportsIndex == -1)
{
if (typeName.Contains("."))
{
candidatesDefineFullNames.Add(typeName);
}
for (var i = 0; i < candidatesNamespaces.Count; i++)
{
candidatesDefineFullNames.Add($"{candidatesNamespaces[i]}.{typeName}");
}
if (!typeName.Contains("."))
{
candidatesDefineFullNames.Add(typeName);
}
}
else
{
if (typeName.Contains("."))
{
candidatesDefineFullNames.Add(typeName);
}
if (!hasGlobal)
{
for (var i = 0; i < firstImportsIndex; i++)
{
candidatesDefineFullNames.Add($"{candidatesNamespaces[i]}.{typeName}");
}
}
if (!typeName.Contains("."))
{
candidatesDefineFullNames.Insert(firstImportsIndex, typeName);
}
for (var i = firstImportsIndex; i < candidatesNamespaces.Count; i++)
{
candidatesDefineFullNames.Add($"{candidatesNamespaces[i]}.{typeName}");
}
}
var genericParts = new List <string>();
// IEnumerable(Of Integer), IEnumerable(Of IEnumerable(Of Integer), Dictionary(Of Integer, Integer)
// Dictionary(Of Integer, Dictionary(Of Integer, Integer))
var node = baseType.ChildNodes().FirstOrDefault();
if (node is GenericNameSyntax)
{
var listNode = node.ChildNodes().FirstOrDefault(); // TypeArgumentListSyntax
var genericTypes = listNode.ChildNodes(); // PredefinedTypeSyntax, GenericNameSyntax, ...
foreach (var genericType in genericTypes)
{
var genericTypeName = genericType.ToString();
genericTypeName = ConvertCSharpTypeWithoutRemoveNamespace(genericTypeName);
genericParts.Add(genericTypeName);
}
}
var startLength = baseType.Span.Start;
var endLength = baseType.Span.End;
items.Add(new BaseTypeInfo
{
CandidatesNamespaces = candidatesNamespaces,
CandidatesDefineFullNames = candidatesDefineFullNames,
BaseType = typeName,
DisplayBaseType = ConvertCSharpType(typeName),
GenericParts = genericParts,
SourceFile = SourceFile,
StartLength = startLength,
EndLength = endLength,
});
}
return(items);
}
