public override void DefaultVisit(ISymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { foreach (var generator in _generators) { generator.DefaultVisit(symbol, item, adapter); } }
internal string AddSpecReference( ISymbol symbol, IReadOnlyList<string> typeGenericParameters, IReadOnlyList<string> methodGenericParameters, Dictionary<string, ReferenceItem> references, SymbolVisitorAdapter adapter) { var id = SpecIdHelper.GetSpecId(symbol, typeGenericParameters, methodGenericParameters); ReferenceItem reference = new ReferenceItem(); reference.Parts = new SortedList<SyntaxLanguage, List<LinkItem>>(); GenerateReferenceInternal(symbol, reference, adapter); reference.IsDefinition = symbol.IsDefinition; if (!symbol.IsDefinition) { var def = symbol.OriginalDefinition; var typeParameters = def.Accept(TypeGenericParameterNameVisitor.Instance); reference.Definition = AddSpecReference(def, typeParameters, null, references, adapter); } reference.Parent = GetReferenceParent(symbol, typeGenericParameters, methodGenericParameters, references, adapter); if (!references.ContainsKey(id)) { references[id] = reference; } else { references[id].Merge(reference); } return id; }
internal override void GenerateReferenceInternal(ISymbol symbol, ReferenceItem reference, SymbolVisitorAdapter adapter) { foreach (var generator in _generators) { generator.GenerateReferenceInternal(symbol, reference, adapter); } }
internal override void GenerateSyntax(MemberType type, ISymbol symbol, SyntaxDetail syntax, SymbolVisitorAdapter adapter) { foreach (var generator in _generators) { generator.GenerateSyntax(type, symbol, syntax, adapter); } }
internal override sealed void GenerateSyntax(MemberType type, ISymbol symbol, SyntaxDetail syntax, SymbolVisitorAdapter adapter) { string syntaxStr = GetSyntaxContent(type, symbol, adapter); Debug.Assert(!string.IsNullOrEmpty(syntaxStr)); if (string.IsNullOrEmpty(syntaxStr)) return; syntax.Content[Language] = syntaxStr; }
public override void GenerateNamedType(INamedTypeSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { base.GenerateNamedType(symbol, item, adapter); var modifiers = new List<string>(); var visiblity = GetVisiblity(symbol.DeclaredAccessibility); if (visiblity != null) { modifiers.Add(visiblity); } if (symbol.TypeKind == TypeKind.Class) { if (symbol.IsAbstract) { modifiers.Add("MustInherit"); } else if (symbol.IsSealed) { modifiers.Add("NotInheritable"); } } switch (symbol.TypeKind) { case TypeKind.Module: modifiers.Add("Module"); break; case TypeKind.Class: if (symbol.IsStatic) { modifiers.Add("Module"); } else { modifiers.Add("Class"); } break; case TypeKind.Delegate: modifiers.Add("Delegate"); break; case TypeKind.Enum: modifiers.Add("Enum"); break; case TypeKind.Interface: modifiers.Add("Interface"); break; case TypeKind.Struct: modifiers.Add("Structure"); break; default: break; } item.Modifiers[SyntaxLanguage.VB] = modifiers; }
internal string AddReference(ISymbol symbol, Dictionary<string, ReferenceItem> references, SymbolVisitorAdapter adapter) { var id = VisitorHelper.GetId(symbol); ReferenceItem reference = new ReferenceItem(); reference.Parts = new SortedList<SyntaxLanguage, List<LinkItem>>(); reference.IsDefinition = symbol.IsDefinition; GenerateReferenceInternal(symbol, reference, adapter); if (!references.ContainsKey(id)) { references[id] = reference; } else { references[id].Merge(reference); } return id; }
internal string AddOverloadReference(ISymbol symbol, Dictionary<string, ReferenceItem> references, SymbolVisitorAdapter adapter) { string uidBody = VisitorHelper.GetOverloadIdBody(symbol); ReferenceItem reference = new ReferenceItem(); reference.Parts = new SortedList<SyntaxLanguage, List<LinkItem>>(); reference.IsDefinition = true; reference.CommentId = "Overload:" + uidBody; GenerateReferenceInternal(symbol, reference, adapter, true); var uid = uidBody + "*"; if (!references.ContainsKey(uid)) { references[uid] = reference; } else { references[uid].Merge(reference); } return uid; }
public override void GenerateMethod(IMethodSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { base.GenerateMethod(symbol, item, adapter); var modifiers = new List<string>(); if (symbol.ContainingType.TypeKind != TypeKind.Interface) { var visiblity = GetVisiblity(symbol.DeclaredAccessibility); if (visiblity != null) { modifiers.Add(visiblity); } if (symbol.IsStatic) { modifiers.Add("static"); } if (symbol.IsAbstract) { modifiers.Add("abstract"); } if (symbol.IsOverride) { modifiers.Add("override"); } if (symbol.IsVirtual && symbol.IsSealed) { } else if (symbol.IsVirtual) { modifiers.Add("virtual"); } else if (symbol.IsSealed) { modifiers.Add("sealed"); } } item.Modifiers[SyntaxLanguage.CSharp] = modifiers; }
public override void GenerateField(IFieldSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { base.GenerateField(symbol, item, adapter); var modifiers = new List<string>(); var visiblity = GetVisiblity(symbol.DeclaredAccessibility); if (visiblity != null) { modifiers.Add(visiblity); } if (symbol.IsConst) { modifiers.Add("const"); } else if (symbol.IsStatic) { modifiers.Add("static"); } if (symbol.IsReadOnly) { modifiers.Add("readonly"); } if (symbol.IsVolatile) { modifiers.Add("volatile"); } item.Modifiers[SyntaxLanguage.CSharp] = modifiers; }
internal abstract void GenerateReferenceInternal(ISymbol symbol, ReferenceItem reference, SymbolVisitorAdapter adapter, bool asOverload = false);
public virtual void GenerateProperty(IPropertySymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { }
internal string AddSpecReference( ISymbol symbol, IReadOnlyList<string> typeGenericParameters, IReadOnlyList<string> methodGenericParameters, Dictionary<string, ReferenceItem> references, SymbolVisitorAdapter adapter) { var rawId = VisitorHelper.GetId(symbol); var id = SpecIdHelper.GetSpecId(symbol, typeGenericParameters, methodGenericParameters); if (string.IsNullOrEmpty(id)) { throw new InvalidDataException($"Fail to parse id for symbol {symbol.MetadataName} in namespace {symbol.ContainingSymbol?.MetadataName}."); } ReferenceItem reference = new ReferenceItem(); reference.Parts = new SortedList<SyntaxLanguage, List<LinkItem>>(); GenerateReferenceInternal(symbol, reference, adapter); var originalSymbol = symbol; var reducedFrom = (symbol as IMethodSymbol)?.ReducedFrom; if (reducedFrom != null) { originalSymbol = reducedFrom; } reference.IsDefinition = (originalSymbol == symbol) && (id == rawId) && (symbol.IsDefinition || VisitorHelper.GetId(symbol.OriginalDefinition) == rawId); if (!reference.IsDefinition.Value && rawId != null) { reference.Definition = AddReference(originalSymbol.OriginalDefinition, references, adapter); } reference.Parent = GetReferenceParent(originalSymbol, typeGenericParameters, methodGenericParameters, references, adapter); reference.CommentId = VisitorHelper.GetCommentId(originalSymbol); if (!references.ContainsKey(id)) { references[id] = reference; } else { references[id].Merge(reference); } return id; }
protected abstract void GenerateReference(ISymbol symbol, ReferenceItem reference, SymbolVisitorAdapter adapter);
public override void DefaultVisit(ISymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { item.DisplayNames[SyntaxLanguage.CSharp] = NameVisitorCreator.GetCSharp(NameOptions.WithGenericParameter | NameOptions.WithParameter).GetName(symbol); item.DisplayNamesWithType[SyntaxLanguage.CSharp] = NameVisitorCreator.GetCSharp(NameOptions.WithType | NameOptions.WithGenericParameter | NameOptions.WithParameter).GetName(symbol); item.DisplayQualifiedNames[SyntaxLanguage.CSharp] = NameVisitorCreator.GetCSharp(NameOptions.Qualified | NameOptions.WithGenericParameter | NameOptions.WithParameter).GetName(symbol); }
public virtual void DefaultVisit(ISymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { }
internal abstract void GenerateSyntax(MemberType type, ISymbol symbol, SyntaxDetail syntax, SymbolVisitorAdapter adapter);
internal abstract void GenerateReferenceInternal(ISymbol symbol, ReferenceItem reference, SymbolVisitorAdapter adapter);
private string GetReferenceParent(ISymbol symbol, IReadOnlyList<string> typeGenericParameters, IReadOnlyList<string> methodGenericParameters, Dictionary<string, ReferenceItem> references, SymbolVisitorAdapter adapter) { switch (symbol.Kind) { case SymbolKind.Event: case SymbolKind.Field: case SymbolKind.Method: case SymbolKind.NamedType: case SymbolKind.Property: { var parentSymbol = symbol; do { parentSymbol = parentSymbol.ContainingSymbol; } while (parentSymbol.Kind == symbol.Kind); // the parent of nested type is namespace. return AddSpecReference(parentSymbol, typeGenericParameters, methodGenericParameters, references, adapter); ; } default: return null; } }
protected override string GetSyntaxContent(MemberType typeKind, ISymbol symbol, SymbolVisitorAdapter adapter) { string syntaxStr = null; switch (typeKind) { case MemberType.Class: { var typeSymbol = (INamedTypeSymbol)symbol; syntaxStr = SyntaxFactory.ClassBlock( SyntaxFactory.ClassStatement( new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetTypeModifiers(typeSymbol)), SyntaxFactory.Token(SyntaxKind.ClassKeyword), SyntaxFactory.Identifier(typeSymbol.Name), GetTypeParameters(typeSymbol)), GetInheritsList(typeSymbol), GetImplementsList(typeSymbol), new SyntaxList<StatementSyntax>(), SyntaxFactory.EndClassStatement()) .NormalizeWhitespace() .ToString(); syntaxStr = RemoveEnd(syntaxStr); break; }; case MemberType.Enum: { var typeSymbol = (INamedTypeSymbol)symbol; syntaxStr = SyntaxFactory.EnumBlock( SyntaxFactory.EnumStatement( new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetTypeModifiers(typeSymbol)), SyntaxFactory.Token(SyntaxKind.EnumKeyword), SyntaxFactory.Identifier(typeSymbol.Name), GetEnumUnderlyingType(typeSymbol))) .NormalizeWhitespace() .ToString(); syntaxStr = RemoveEnd(syntaxStr); break; }; case MemberType.Interface: { var typeSymbol = (INamedTypeSymbol)symbol; syntaxStr = SyntaxFactory.InterfaceBlock( SyntaxFactory.InterfaceStatement( new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetTypeModifiers(typeSymbol)), SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), SyntaxFactory.Identifier(typeSymbol.Name), GetTypeParameters(typeSymbol)), GetInheritsList(typeSymbol), new SyntaxList<ImplementsStatementSyntax>(), new SyntaxList<StatementSyntax>(), SyntaxFactory.EndInterfaceStatement()) .NormalizeWhitespace() .ToString(); syntaxStr = RemoveEnd(syntaxStr); break; }; case MemberType.Struct: { var typeSymbol = (INamedTypeSymbol)symbol; syntaxStr = SyntaxFactory.StructureBlock( SyntaxFactory.StructureStatement( new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetTypeModifiers(typeSymbol)), SyntaxFactory.Token(SyntaxKind.StructureKeyword), SyntaxFactory.Identifier(typeSymbol.Name), GetTypeParameters(typeSymbol)), new SyntaxList<InheritsStatementSyntax>(), GetImplementsList(typeSymbol), new SyntaxList<StatementSyntax>(), SyntaxFactory.EndStructureStatement()) .NormalizeWhitespace() .ToString(); syntaxStr = RemoveEnd(syntaxStr); break; }; case MemberType.Delegate: { var typeSymbol = (INamedTypeSymbol)symbol; syntaxStr = SyntaxFactory.DelegateStatement( typeSymbol.DelegateInvokeMethod.ReturnsVoid ? SyntaxKind.DelegateSubStatement : SyntaxKind.DelegateFunctionStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetTypeModifiers(typeSymbol)), typeSymbol.DelegateInvokeMethod.ReturnsVoid ? SyntaxFactory.Token(SyntaxKind.SubKeyword) : SyntaxFactory.Token(SyntaxKind.FunctionKeyword), SyntaxFactory.Identifier(typeSymbol.Name), GetTypeParameters(typeSymbol), GetParamerterList(typeSymbol.DelegateInvokeMethod), GetReturnAsClause(typeSymbol.DelegateInvokeMethod)) .NormalizeWhitespace() .ToString(); syntaxStr = RemoveEnd(syntaxStr); break; }; case MemberType.Method: { var methodSymbol = (IMethodSymbol)symbol; syntaxStr = SyntaxFactory.MethodStatement( methodSymbol.ReturnsVoid ? SyntaxKind.SubStatement : SyntaxKind.FunctionStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetMemberModifiers(methodSymbol)), methodSymbol.ReturnsVoid ? SyntaxFactory.Token(SyntaxKind.SubKeyword) : SyntaxFactory.Token(SyntaxKind.FunctionKeyword), SyntaxFactory.Identifier(methodSymbol.Name), GetTypeParameters(methodSymbol), GetParamerterList(methodSymbol), GetReturnAsClause(methodSymbol), null, GetImplementsClause(methodSymbol)) .NormalizeWhitespace() .ToString(); syntaxStr = RemoveEnd(syntaxStr); break; }; case MemberType.Operator: { var methodSymbol = (IMethodSymbol)symbol; var operatorToken = GetOperatorToken(methodSymbol); if (operatorToken == null) { syntaxStr = "VB cannot support this operator."; } else { syntaxStr = SyntaxFactory.OperatorStatement( new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetMemberModifiers(methodSymbol)), SyntaxFactory.Token(SyntaxKind.OperatorKeyword), operatorToken.Value, GetParamerterList(methodSymbol), GetReturnAsClause(methodSymbol)) .NormalizeWhitespace() .ToString(); } break; }; case MemberType.Constructor: { var methodSymbol = (IMethodSymbol)symbol; syntaxStr = SyntaxFactory.SubNewStatement( new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetMemberModifiers(methodSymbol)), GetParamerterList(methodSymbol)) .NormalizeWhitespace() .ToString(); syntaxStr = RemoveEnd(syntaxStr); break; }; case MemberType.Field: { var fieldSymbol = (IFieldSymbol)symbol; if (fieldSymbol.ContainingType.TypeKind == TypeKind.Enum) { syntaxStr = SyntaxFactory.EnumMemberDeclaration( new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Identifier(fieldSymbol.Name), GetDefaultValue(fieldSymbol)) .NormalizeWhitespace() .ToString(); } else { syntaxStr = SyntaxFactory.FieldDeclaration( new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetMemberModifiers(fieldSymbol)), SyntaxFactory.SingletonSeparatedList( SyntaxFactory.VariableDeclarator( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.ModifiedIdentifier(symbol.Name)), fieldSymbol.ContainingType.TypeKind == TypeKind.Enum ? null : SyntaxFactory.SimpleAsClause( GetTypeSyntax(fieldSymbol.Type)), GetDefaultValue(fieldSymbol)))) .NormalizeWhitespace() .ToString(); } syntaxStr = RemoveEnd(syntaxStr); break; }; case MemberType.Event: { var eventSymbol = (IEventSymbol)symbol; syntaxStr = SyntaxFactory.EventStatement( new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetMemberModifiers(eventSymbol)), SyntaxFactory.Identifier(eventSymbol.Name), null, SyntaxFactory.SimpleAsClause( GetTypeSyntax(eventSymbol.Type)), GetImplementsClause(eventSymbol)) .NormalizeWhitespace() .ToString(); break; }; case MemberType.Property: { var propertySymbol = (IPropertySymbol)symbol; syntaxStr = SyntaxFactory.PropertyStatement( new SyntaxList<AttributeListSyntax>(), SyntaxFactory.TokenList(GetMemberModifiers(propertySymbol)), SyntaxFactory.Identifier(propertySymbol.MetadataName), GetParamerterList(propertySymbol), SyntaxFactory.SimpleAsClause( GetTypeSyntax(propertySymbol.Type)), null, GetImplementsClause(propertySymbol)) .NormalizeWhitespace() .ToString(); break; }; } return syntaxStr; }
protected override void GenerateReference(ISymbol symbol, ReferenceItem reference, SymbolVisitorAdapter adapter) { symbol.Accept(new VBReferenceItemVisitor(reference)); }
public override void GenerateProperty(IPropertySymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { base.GenerateProperty(symbol, item, adapter); var modifiers = new List<string>(); var propertyVisiblity = GetVisiblity(symbol.DeclaredAccessibility); if (symbol.ContainingType.TypeKind != TypeKind.Interface) { if (propertyVisiblity != null) { modifiers.Add(propertyVisiblity); } if (symbol.IsStatic) { modifiers.Add("static"); } if (symbol.IsAbstract) { modifiers.Add("abstract"); } if (symbol.IsOverride) { modifiers.Add("override"); } if (symbol.IsVirtual && symbol.IsSealed) { } else if (symbol.IsVirtual) { modifiers.Add("virtual"); } else if (symbol.IsSealed) { modifiers.Add("sealed"); } } if (symbol.GetMethod != null) { var getMethodVisiblity = GetVisiblity(symbol.GetMethod.DeclaredAccessibility); if (propertyVisiblity != null && getMethodVisiblity == null) { } else if (getMethodVisiblity != propertyVisiblity) { modifiers.Add($"{getMethodVisiblity} get"); } else { modifiers.Add("get"); } } if (symbol.SetMethod != null) { var setMethodVisiblity = GetVisiblity(symbol.SetMethod.DeclaredAccessibility); if (propertyVisiblity != null && setMethodVisiblity == null) { } else if (setMethodVisiblity != propertyVisiblity) { modifiers.Add($"{setMethodVisiblity} set"); } else { modifiers.Add("set"); } } item.Modifiers[SyntaxLanguage.CSharp] = modifiers; }
protected override string GetSyntaxContent(MemberType typeKind, ISymbol symbol, SymbolVisitorAdapter adapter) { switch (typeKind) { case MemberType.Class: return GetClassSyntax((INamedTypeSymbol)symbol, adapter.FilterVisitor); case MemberType.Enum: return GetEnumSyntax((INamedTypeSymbol)symbol, adapter.FilterVisitor); case MemberType.Interface: return GetInterfaceSyntax((INamedTypeSymbol)symbol, adapter.FilterVisitor); case MemberType.Struct: return GetStructSyntax((INamedTypeSymbol)symbol, adapter.FilterVisitor); case MemberType.Delegate: return GetDelegateSyntax((INamedTypeSymbol)symbol, adapter.FilterVisitor); case MemberType.Method: return GetMethodSyntax((IMethodSymbol)symbol, adapter.FilterVisitor); case MemberType.Operator: return GetOperatorSyntax((IMethodSymbol)symbol, adapter.FilterVisitor); case MemberType.Constructor: return GetConstructorSyntax((IMethodSymbol)symbol, adapter.FilterVisitor); case MemberType.Field: return GetFieldSyntax((IFieldSymbol)symbol, adapter.FilterVisitor); case MemberType.Event: return GetEventSyntax((IEventSymbol)symbol, adapter.FilterVisitor); case MemberType.Property: return GetPropertySyntax((IPropertySymbol)symbol, adapter.FilterVisitor); default: return null; } }
protected abstract string GetSyntaxContent(MemberType typeKind, ISymbol symbol, SymbolVisitorAdapter adapter);
protected override void GenerateReference(ISymbol symbol, ReferenceItem reference, SymbolVisitorAdapter adapter, bool asOverload) { symbol.Accept(new CSReferenceItemVisitor(reference, asOverload)); }
public virtual void GenerateMethod(IMethodSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { }
internal override sealed void GenerateReferenceInternal(ISymbol symbol, ReferenceItem reference, SymbolVisitorAdapter adapter) { GenerateReference(symbol, reference, adapter); }
public virtual void GenerateField(IFieldSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { }
public virtual void GenerateNamedType(INamedTypeSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { }
public virtual void GenerateEvent(IEventSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { }