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