private async Task <Document> FixSharedInterfaceAsync(Document document, InterfaceDeclarationSyntax interfaceType, SemanticModel model, CancellationToken cancellationToken)
{
var editor = await DocumentEditor.CreateAsync(document);
var seq = interfaceType.ChildNodes()
.OfType <MethodDeclarationSyntax>()
.Select(x => new
{
targetMethod = x,
methodSymbol = model.GetDeclaredSymbol(x),
returnType = model.GetDeclaredSymbol(x)?.ReturnType as INamedTypeSymbol
})
.Where(x => {
return(!x.methodSymbol.GetAttributes().Any(attr => attr.AttributeClass.Name == "OperationAttribute"));
})
.Where(x => x.returnType != null)
.Select(x =>
{
return(new { x.targetMethod, newMethod = FixAsyncFunctionMethod(x.targetMethod, cancellationToken) });
});
foreach (var item in seq)
{
editor.ReplaceNode(item.targetMethod, item.newMethod);
}
return(editor.GetChangedDocument());
}
public override void VisitInterfaceDeclaration(InterfaceDeclarationSyntax node)
{
var isPartial = node.ChildTokens().Any(x => x.Kind() == SyntaxKind.PartialKeyword);
var defineName = node.ChildTokens().FirstOrDefault(x => x.Kind() == SyntaxKind.IdentifierToken).ToString();
// ジェネリック型を定義している場合
if (node.ChildNodes().OfType <TypeParameterListSyntax>().Any())
{
var listNode = node.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.Interface, startLength, endLength);
var baseTypeInfos = new List <BaseTypeInfo>();
// 継承元クラス、またはインターフェースがある場合
if (node.ChildNodes().OfType <BaseListSyntax>().Any())
{
var listNode = node.ChildNodes().OfType <BaseListSyntax>().FirstOrDefault();
var baseTypes = listNode.ChildNodes().OfType <SimpleBaseTypeSyntax>();
baseTypeInfos = GetBaseTypeInfos(baseTypes, parentNamespace);
}
UserDefinitions.Add(new UserDefinition
{
DefineKinds = DefineKinds.Interface,
IsPartial = isPartial,
Namespace = parentNamespace,
DefineName = defineName,
DefineFullName = $"{parentNamespace}.{defineName}",
BaseTypeInfos = baseTypeInfos,
SourceFile = SourceFile,
StartLength = startLength,
EndLength = endLength,
});
base.VisitInterfaceDeclaration(node);
}
internal static InterfaceSpec AnalyzeInterfaceSyntaxTree(string napackName, string filename, InterfaceDeclarationSyntax interfaceNode)
{
InterfaceSpec interfaceSpec = new InterfaceSpec();
interfaceSpec.Name = DocumentedElement.LoadFromSyntaxNode(interfaceNode);
// Parse methods
foreach (MethodDeclarationSyntax node in interfaceNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.MethodDeclaration)))
{
interfaceSpec.Methods.Add(MethodSpec.LoadFromSyntaxNode(node));
}
// Parse properties
foreach (PropertyDeclarationSyntax node in interfaceNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.PropertyDeclaration)))
{
interfaceSpec.Properties.Add(PropertySpec.LoadFromSyntaxNode(node));
}
return(interfaceSpec);
}
public override void VisitInterfaceDeclaration(InterfaceDeclarationSyntax node)
{
if (node.ShouldBeHidden()) return;
if (node.ChildNodes().All(childNode => childNode is PropertyDeclarationSyntax || childNode is AttributeListSyntax))
{
// simple nested interface
var line = node.SyntaxTree.GetLineSpan(node.Span).StartLinePosition.Line;
var walker = new CodeWithDocumentationWalker(0, line);
walker.Visit(node);
this.Blocks.AddRange(walker.Blocks);
}
}
public override void VisitInterfaceDeclaration(InterfaceDeclarationSyntax node)
{
if (node.ShouldBeHidden())
{
return;
}
if (node.ChildNodes().All(childNode => childNode.IsKind(SyntaxKind.PropertyDeclaration) ||
childNode.IsKind(SyntaxKind.AttributeList)))
{
// simple nested interface
AddNestedType(node);
}
}
public override void VisitInterfaceDeclaration(InterfaceDeclarationSyntax node)
{
if (node.ShouldBeHidden())
{
return;
}
if (node.ChildNodes().All(childNode => childNode is PropertyDeclarationSyntax || childNode is AttributeListSyntax))
{
// simple nested interface
var line = node.SyntaxTree.GetLineSpan(node.Span).StartLinePosition.Line;
var walker = new CodeWithDocumentationWalker(0, line);
walker.Visit(node);
this.Blocks.AddRange(walker.Blocks);
}
}
InterfaceRenderInformation renderInterface(InterfaceDeclarationSyntax interfaceDecl)
{
var ret = new InterfaceRenderInformation();
ret.isRoutableViewModel = interfaceDecl.BaseListOpt.Types.Any(x => x.PlainName == "IRoutableViewModel") ? this : null;
ret.definition = chompedString(interfaceDecl.ToString().Replace("[Once]", ""));
ret.interfaceName = chompedString(interfaceDecl.Identifier.ValueText);
ret.implClassName = ret.interfaceName.Substring(1); // Skip the 'I'
var children = interfaceDecl.ChildNodes().Skip(1);
ret.properties = children.Select(renderPropertyDeclaration).ToArray();
ret.onceProperties = ret.properties.Where(x => x.onceProp != null).Select(x => x.onceProp).ToArray();
return ret;
}
void ExportInterface(InterfaceDeclarationSyntax c)
{
string name = "";
string nameSpace = "";
NamespaceDeclarationSyntax namespaceDeclarationSyntax = c.Parent as NamespaceDeclarationSyntax;
if (namespaceDeclarationSyntax != null)
{
nameSpace = namespaceDeclarationSyntax.Name.ToString();
}
else
{
nameSpace = ModelData.GloableNamespaceName;
}
name = c.Identifier.Text;
if (step == ECompilerStet.ScanType)
{
type_list.Add(new ULTypeInfo());
types.Push(type_list[type_list.Count - 1]);
currentType.Namespace = nameSpace;
currentType.Name = name;
currentType.IsInterface = true;
ModelData.UpdateType(currentType);
}
else
{
types.Push(ModelData.FindTypeByFullName(nameSpace + "." + name));
}
////导出所有变量
//var virableNodes = c.ChildNodes().OfType<BaseFieldDeclarationSyntax>();
//foreach (var v in virableNodes)
//{
// ExportVariable(v);
//}
//导出所有属性
var propertyNodes = c.ChildNodes().OfType <BasePropertyDeclarationSyntax>();
foreach (var v in propertyNodes)
{
ExportProperty(v);
}
//导出所有方法
var funcNodes = c.ChildNodes().OfType <BaseMethodDeclarationSyntax>();
foreach (var f in funcNodes)
{
ExportMethod(f);
}
var operatorNodes = c.ChildNodes().OfType <OperatorDeclarationSyntax>();
foreach (var f in operatorNodes)
{
//ExportOperator(f, type);
}
var conversion_operatorNodes = c.ChildNodes().OfType <ConversionOperatorDeclarationSyntax>();
foreach (var f in conversion_operatorNodes)
{
//ExportConversionOperator(f, type);
}
types.Pop();
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="node">対象Node</param>
/// <param name="semanticModel">対象ソースのsemanticModel</param>
/// <param name="parent">親IAnalyzeItem</param>
/// <param name="container">イベントコンテナ</param>
public ItemInterface(InterfaceDeclarationSyntax node, SemanticModel semanticModel, IAnalyzeItem parent, EventContainer container) : base(parent, node, semanticModel, container)
{
ItemType = ItemTypes.Interface;
var declaredSymbol = semanticModel.GetDeclaredSymbol(node);
// インターフェース設定
if (node.BaseList != null)
{
// インターフェース
foreach (var interfaceInfo in declaredSymbol.AllInterfaces)
{
Interfaces.Add(getExpressionList(interfaceInfo));
// スーパーインタフェースのメンバーを追加する
SetBaseMembers(interfaceInfo);
}
// 対象をList<IExpression>に格納する
List <IExpression> getExpressionList(INamedTypeSymbol target)
{
var result = new List <IExpression>();
var displayParts = target.ToDisplayParts(SymbolDisplayFormat.MinimallyQualifiedFormat);
foreach (var part in displayParts)
{
// スペースの場合は型設定に含めない
if (part.Kind == SymbolDisplayPartKind.Space)
{
continue;
}
var name = Expression.GetSymbolName(part, true);
var type = Expression.GetSymbolTypeName(part.Symbol);
if (part.Symbol != null)
{
type = part.Symbol.GetType().Name;
if (part.Kind == SymbolDisplayPartKind.ClassName || part.Kind == SymbolDisplayPartKind.InterfaceName)
{
// 外部ファイル参照イベント発行
RaiseOtherFileReferenced(node, part.Symbol);
}
}
result.Add(new Expression(name, type));
}
return(result);
}
}
// ジェネリックタイプ
if (declaredSymbol.TypeParameters.Any())
{
var types = declaredSymbol.TypeParameters.Select(item => item.Name);
GenericTypes.AddRange(types);
}
// メンバ
foreach (var childSyntax in node.ChildNodes())
{
var memberResult = ItemFactory.Create(childSyntax, semanticModel, container, this);
if (memberResult != null)
{
Members.Add(memberResult);
}
}
}
private Interface TraverseInterface(InterfaceDeclarationSyntax ids)
{
Interface retInterface = new Interface();
if (ids.HasLeadingTrivia)
{
SetOuterComments(retInterface, ids.GetLeadingTrivia().ToFullString());
}
if (ids.HasTrailingTrivia)
{
SetInnerComments(retInterface, ids.GetTrailingTrivia().ToFullString());
}
foreach (SyntaxToken st in ids.Modifiers)
{
string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
Encapsulation encap;
Qualifiers qual;
if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
{
retInterface.Encapsulation.Add(encap);
}
else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
{
retInterface.Qualifiers.Add(qual);
}
}
var accessVarsDecl = from aAccessVarsDecl in ids.ChildNodes().OfType<LocalDeclarationStatementSyntax>() select aAccessVarsDecl;
foreach (LocalDeclarationStatementSyntax ldss in accessVarsDecl)
{
Method tempMethod = TransverseAccessVars(ldss);
retInterface.Fields.AddRange(tempMethod.AccessedVariables);
//retInterface.Methods.AddRange(tempMethod.InvokedMethods);
}
var interfaces = from aInterface in ids.ChildNodes().OfType<InterfaceDeclarationSyntax>() select aInterface;
foreach (InterfaceDeclarationSyntax ids2 in interfaces)
{
Interface tempInterface = TraverseInterface(ids2);
retInterface.InheritsInterfaces.Add(tempInterface);
}
retInterface.Name = ids.Identifier.ValueText;
var methods = from aMethod in ids.ChildNodes().OfType<MethodDeclarationSyntax>() select aMethod;
foreach (MethodDeclarationSyntax mds in methods)
{
Method tempMethod = TransverseMethods(mds);
retInterface.Fields.AddRange(tempMethod.AccessedVariables);
retInterface.Methods.Add(tempMethod);
}
//public List<string> InheritsStrings { get; set; }
//public List<Property> Properties { get; set; }
return retInterface;
}
