public bool CanVisitAttribute(ISymbol symbol, bool wantProtectedMember, IFilterVisitor outer)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
return CanVisitCore(symbol, (outer ?? this).CanVisitAttribute, wantProtectedMember, outer ?? this);
}
public override TResult Accept <TResult>(IParseTreeVisitor <TResult> visitor)
{
IFilterVisitor <TResult> typedVisitor = visitor as IFilterVisitor <TResult>;
if (typedVisitor != null)
{
return(typedVisitor.VisitStringOp(this));
}
else
{
return(visitor.VisitChildren(this));
}
}
protected override bool CanVisitAttributeCore(ISymbol symbol, bool wantProtectedMember, IFilterVisitor outer)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
if (!Inner.CanVisitAttribute(symbol, wantProtectedMember, outer))
{
return false;
}
return CanVisitCore(_configRule.AttributeRules, symbol);
}
private static bool CanVisitCore(IFieldSymbol symbol, bool wantProtected, IFilterVisitor outer)
{
switch (symbol.DeclaredAccessibility)
{
case Accessibility.Public:
return(true);
case Accessibility.Protected:
case Accessibility.ProtectedOrInternal:
return(wantProtected);
default:
break;
}
return(false);
}
private static bool CanVisitCore(IEventSymbol symbol, Func<ISymbol, bool, IFilterVisitor, bool> visitFunc, bool wantProtectedMember, IFilterVisitor outer)
{
switch (symbol.DeclaredAccessibility)
{
case Accessibility.Public:
return true;
case Accessibility.Protected:
case Accessibility.ProtectedOrInternal:
return wantProtectedMember;
default:
break;
}
if (symbol.ExplicitInterfaceImplementations.Length > 0)
{
for (int i = 0; i < symbol.ExplicitInterfaceImplementations.Length; i++)
{
if (visitFunc(symbol.ExplicitInterfaceImplementations[i].ContainingType, false, outer))
{
return true;
}
}
}
return false;
}
private bool CanVisitCore(IEnumerable <ConfigFilterRuleItemUnion> ruleItems, ISymbol symbol, bool wantProtectedMember, IFilterVisitor outer)
{
var current = symbol;
var parent = symbol.ContainingSymbol;
while (!(current is INamespaceSymbol) && parent != null)
{
if (!outer.CanVisitApi(parent, wantProtectedMember, outer))
{
return(false);
}
current = parent;
parent = parent.ContainingSymbol;
}
foreach (var ruleUnion in ruleItems)
{
ConfigFilterRuleItem rule = ruleUnion.Rule;
if (rule != null && rule.IsMatch(symbol))
{
return(rule.CanVisit);
}
}
return(true);
}
private static SyntaxList<AttributeListSyntax> GetAttributes(ISymbol symbol, IFilterVisitor filterVisitor, bool inOneLine = false, bool isExtensionMethod = false)
{
var attrs = symbol.GetAttributes();
List<AttributeSyntax> attrList = null;
if (attrs.Length > 0)
{
attrList = (from attr in attrs
where !(attr.AttributeClass is IErrorTypeSymbol)
where attr?.AttributeConstructor != null
where filterVisitor.CanVisitAttribute(attr.AttributeConstructor)
select GetAttributeSyntax(attr)).ToList();
}
if (isExtensionMethod)
{
attrList = attrList ?? new List<AttributeSyntax>();
attrList.Add(
SyntaxFactory.Attribute(
SyntaxFactory.ParseName(nameof(System.Runtime.CompilerServices.ExtensionAttribute))));
}
if (attrList?.Count > 0)
{
if (inOneLine)
{
return SyntaxFactory.SingletonList(
SyntaxFactory.AttributeList(
SyntaxFactory.SeparatedList(attrList)));
}
return SyntaxFactory.List(
from attr in attrList
select SyntaxFactory.AttributeList(
SyntaxFactory.SingletonSeparatedList(attr)));
}
return new SyntaxList<AttributeListSyntax>();
}
public static IFilterVisitor WithConfig(this IFilterVisitor fv, ConfigFilterRule rule)
{
return(new ConfigFilterVisitor(fv, rule));
}
private static SyntaxList<AttributeListSyntax> GetAttributes(ISymbol symbol, IFilterVisitor filterVisitor, bool inOneLine = false)
{
var attrs = symbol.GetAttributes();
if (attrs.Length > 0)
{
var attrList = (from attr in attrs
where !(attr.AttributeClass is IErrorTypeSymbol)
where attr?.AttributeConstructor != null
where filterVisitor.CanVisitAttribute(attr.AttributeConstructor)
select GetAttributeSyntax(attr)).ToList();
if (attrList.Count > 0)
{
if (inOneLine)
{
return SyntaxFactory.SingletonList(
SyntaxFactory.AttributeList(
SyntaxFactory.SeparatedList(attrList)));
}
return SyntaxFactory.List(
from attr in attrList
select SyntaxFactory.AttributeList(
SyntaxFactory.SingletonSeparatedList(attr)));
}
}
return new SyntaxList<AttributeListSyntax>();
}
public DelegatingFilterVisitor(IFilterVisitor inner)
{
Inner = inner;
}
public List <double> Accept(IFilterVisitor <List <double> > filter)
{
throw new NotImplementedException();
}
public ConfigFilterVisitor(IFilterVisitor inner, ConfigFilterRule rule)
: base(inner)
{
_configRule = rule;
}
public ConfigFilterVisitor(IFilterVisitor inner, string configFile)
: base(inner)
{
_configFile = configFile;
_configRule = LoadRules(configFile);
}
private static bool CanVisitCore(ISymbol symbol, bool wantProtectedMember, IFilterVisitor outer)
{
if (symbol.DeclaredAccessibility == Accessibility.NotApplicable)
{
return(true);
}
if (symbol.IsImplicitlyDeclared)
{
return(false);
}
var methodSymbol = symbol as IMethodSymbol;
if (methodSymbol != null)
{
return(CanVisitCore(methodSymbol, wantProtectedMember, outer));
}
var propertySymbol = symbol as IPropertySymbol;
if (propertySymbol != null)
{
return(CanVisitCore(propertySymbol, wantProtectedMember, outer));
}
var eventSymbol = symbol as IEventSymbol;
if (eventSymbol != null)
{
return(CanVisitCore(eventSymbol, wantProtectedMember, outer));
}
var fieldSymbol = symbol as IFieldSymbol;
if (fieldSymbol != null)
{
return(CanVisitCore(fieldSymbol, wantProtectedMember, outer));
}
var namedTypeSymbol = symbol as INamedTypeSymbol;
if (namedTypeSymbol != null)
{
return(CanVisitCore(namedTypeSymbol, wantProtectedMember, outer));
}
var ts = symbol as ITypeSymbol;
if (ts != null)
{
switch (ts.TypeKind)
{
case TypeKind.Dynamic:
case TypeKind.TypeParameter:
return(true);
case TypeKind.Unknown:
case TypeKind.Error:
return(false);
case TypeKind.Array:
return(outer.CanVisitApi(((IArrayTypeSymbol)ts).ElementType, wantProtectedMember, outer));
case TypeKind.Pointer:
return(outer.CanVisitApi(((IPointerTypeSymbol)ts).PointedAtType, wantProtectedMember, outer));
default:
break;
}
}
if (symbol.DeclaredAccessibility != Accessibility.Public)
{
return(false);
}
return(true);
}
protected virtual bool CanVisitAttributeCore(ISymbol symbol, bool wantProtectedMember, IFilterVisitor outer)
{
return Inner.CanVisitAttribute(symbol, wantProtectedMember, outer);
}
public bool CanVisitAttribute(ISymbol symbol, bool wantProtectedMember, IFilterVisitor outer)
{
return CanVisitAttributeCore(symbol, wantProtectedMember, outer ?? this);
}
private static bool CanVisitCore(IFieldSymbol symbol, Func<ISymbol, bool, IFilterVisitor, bool> visitFunc, bool wantProtected, IFilterVisitor outer)
{
switch (symbol.DeclaredAccessibility)
{
case Accessibility.Public:
return true;
case Accessibility.Protected:
case Accessibility.ProtectedOrInternal:
return wantProtected;
default:
break;
}
return false;
}
private string GetStructSyntax(INamedTypeSymbol symbol, IFilterVisitor filterVisitor) =>
RemoveBraces(
SyntaxFactory.StructDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(
GetTypeModifiers(symbol)
),
SyntaxFactory.Identifier(symbol.Name),
GetTypeParameters(symbol),
GetBaseTypeList(symbol),
SyntaxFactory.List(
GetTypeParameterConstraints(symbol)
),
new SyntaxList<MemberDeclarationSyntax>()
).NormalizeWhitespace().ToString()
);
public override TResult AcceptVisitor <TArg, TResult>(IFilterVisitor <TArg, TResult> visitor, TArg arg)
{
return(visitor.Visit(this, arg));
}
private string GetConstructorSyntax(IMethodSymbol symbol, IFilterVisitor filterVisitor) =>
SyntaxFactory.ConstructorDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(
GetMemberModifiers(symbol)
),
SyntaxFactory.Identifier(symbol.ContainingType.Name),
SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList(
from p in symbol.Parameters
select GetParameter(p, filterVisitor)
)
),
null,
null
).NormalizeWhitespace().ToString();
private static AccessorDeclarationSyntax GetPropertyAccessorCore(
IPropertySymbol propertySymbol, IMethodSymbol methodSymbol,
SyntaxKind kind, SyntaxKind keyword, IFilterVisitor filterVisitor)
{
if (methodSymbol == null)
{
return null;
}
switch (methodSymbol.DeclaredAccessibility)
{
case Accessibility.Protected:
case Accessibility.ProtectedOrInternal:
if (propertySymbol.DeclaredAccessibility == Accessibility.Protected ||
propertySymbol.DeclaredAccessibility == Accessibility.ProtectedOrInternal)
{
return SyntaxFactory.AccessorDeclaration(kind,
GetAttributes(methodSymbol, filterVisitor),
new SyntaxTokenList(),
SyntaxFactory.Token(keyword),
null,
SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
else
{
return SyntaxFactory.AccessorDeclaration(
kind,
GetAttributes(methodSymbol, filterVisitor),
SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword)),
SyntaxFactory.Token(keyword),
null,
SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
case Accessibility.Public:
return SyntaxFactory.AccessorDeclaration(kind,
GetAttributes(methodSymbol, filterVisitor),
new SyntaxTokenList(),
SyntaxFactory.Token(keyword),
null,
SyntaxFactory.Token(SyntaxKind.SemicolonToken));
default:
if (methodSymbol.ExplicitInterfaceImplementations.Length > 0)
{
return SyntaxFactory.AccessorDeclaration(kind,
GetAttributes(methodSymbol, filterVisitor),
new SyntaxTokenList(),
SyntaxFactory.Token(keyword),
null,
SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
return null;
}
}
public abstract TResult Accept <TArgument, TResult>(IFilterVisitor <TArgument, TResult> visitor, TArgument argument);
private string GetMethodSyntax(IMethodSymbol symbol, IFilterVisitor filterVisitor)
{
ExplicitInterfaceSpecifierSyntax eii = null;
if (symbol.ExplicitInterfaceImplementations.Length > 0)
{
eii = SyntaxFactory.ExplicitInterfaceSpecifier(SyntaxFactory.ParseName(GetEiiContainerTypeName(symbol, filterVisitor)));
}
return SyntaxFactory.MethodDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(
GetMemberModifiers(symbol)
),
GetTypeSyntax(symbol.ReturnType),
eii,
SyntaxFactory.Identifier(
GetMemberName(symbol, filterVisitor)
),
GetTypeParameters(symbol),
SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList(
symbol.Parameters.Select((p, i) => GetParameter(p, filterVisitor, i == 0 && symbol.IsExtensionMethod))
)
),
SyntaxFactory.List(
GetTypeParameterConstraints(symbol)
),
null,
null
).NormalizeWhitespace().ToString();
}
/// <inheritdoc />
public override void Accept(IFilterVisitor visitor)
{
visitor.VisitPropertyFilter(this);
}
private string GetEventSyntax(IEventSymbol symbol, IFilterVisitor filterVisitor)
{
ExplicitInterfaceSpecifierSyntax eii = null;
if (symbol.ExplicitInterfaceImplementations.Length > 0)
{
eii = SyntaxFactory.ExplicitInterfaceSpecifier(SyntaxFactory.ParseName(GetEiiContainerTypeName(symbol, filterVisitor)));
}
return RemoveBraces(
SyntaxFactory.EventDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(GetMemberModifiers(symbol)),
SyntaxFactory.Token(SyntaxKind.EventKeyword),
GetTypeSyntax(symbol.Type),
eii,
SyntaxFactory.Identifier(GetMemberName(symbol, filterVisitor)),
SyntaxFactory.AccessorList()
).NormalizeWhitespace().ToString()
);
}
private static bool CanVisitCore(INamedTypeSymbol symbol, Func <ISymbol, bool, IFilterVisitor, bool> visitFunc, bool wantProtectedMember, IFilterVisitor outer)
{
if (symbol.ContainingType != null)
{
switch (symbol.DeclaredAccessibility)
{
case Accessibility.Public:
return(visitFunc(symbol.ContainingType, wantProtectedMember, outer));
case Accessibility.Protected:
case Accessibility.ProtectedOrInternal:
return(wantProtectedMember && visitFunc(symbol.ContainingType, wantProtectedMember, outer));
default:
return(false);
}
}
return(symbol.DeclaredAccessibility == Accessibility.Public);
}
private static string GetEiiContainerTypeName(IPropertySymbol symbol, IFilterVisitor filterVisitor)
{
if (symbol.ExplicitInterfaceImplementations.Length == 0)
{
return null;
}
for (int i = 0; i < symbol.ExplicitInterfaceImplementations.Length; i++)
{
if (filterVisitor.CanVisitApi(symbol.ExplicitInterfaceImplementations[i]))
{
return NameVisitorCreator.GetCSharp(NameOptions.UseAlias | NameOptions.WithGenericParameter).GetName(symbol.ExplicitInterfaceImplementations[i].ContainingType);
}
}
Debug.Fail("Should not be here!");
return null;
}
private static bool CanVisitCore(IEventSymbol symbol, Func <ISymbol, bool, IFilterVisitor, bool> visitFunc, bool wantProtectedMember, IFilterVisitor outer)
{
switch (symbol.DeclaredAccessibility)
{
case Accessibility.Public:
return(true);
case Accessibility.Protected:
case Accessibility.ProtectedOrInternal:
return(wantProtectedMember);
default:
break;
}
if (symbol.ExplicitInterfaceImplementations.Length > 0)
{
for (int i = 0; i < symbol.ExplicitInterfaceImplementations.Length; i++)
{
if (visitFunc(symbol.ExplicitInterfaceImplementations[i].ContainingType, false, outer))
{
return(true);
}
}
}
return(false);
}
public static IFilterVisitor WithConfig(this IFilterVisitor fv, string configFile)
{
return(new ConfigFilterVisitor(fv, configFile));
}
private static bool CanVisitCore(ISymbol symbol, Func <ISymbol, bool, IFilterVisitor, bool> visitFunc, bool wantProtectedMember, IFilterVisitor outer)
{
// check parent visibility
var current = symbol;
var parent = symbol.ContainingSymbol;
while (!(current is INamespaceSymbol) && parent != null)
{
if (!visitFunc(parent, wantProtectedMember, outer))
{
return(false);
}
current = parent;
parent = parent.ContainingSymbol;
}
if (symbol.DeclaredAccessibility == Accessibility.NotApplicable)
{
return(true);
}
if (!(symbol is INamespaceSymbol) && symbol.IsImplicitlyDeclared)
{
return(false);
}
var methodSymbol = symbol as IMethodSymbol;
if (methodSymbol != null)
{
return(CanVisitCore(methodSymbol, visitFunc, wantProtectedMember, outer));
}
var propertySymbol = symbol as IPropertySymbol;
if (propertySymbol != null)
{
return(CanVisitCore(propertySymbol, visitFunc, wantProtectedMember, outer));
}
var eventSymbol = symbol as IEventSymbol;
if (eventSymbol != null)
{
return(CanVisitCore(eventSymbol, visitFunc, wantProtectedMember, outer));
}
var fieldSymbol = symbol as IFieldSymbol;
if (fieldSymbol != null)
{
return(CanVisitCore(fieldSymbol, visitFunc, wantProtectedMember, outer));
}
var namedTypeSymbol = symbol as INamedTypeSymbol;
if (namedTypeSymbol != null)
{
return(CanVisitCore(namedTypeSymbol, visitFunc, wantProtectedMember, outer));
}
var ts = symbol as ITypeSymbol;
if (ts != null)
{
switch (ts.TypeKind)
{
case TypeKind.Dynamic:
case TypeKind.TypeParameter:
return(true);
case TypeKind.Unknown:
case TypeKind.Error:
return(false);
case TypeKind.Array:
return(visitFunc(((IArrayTypeSymbol)ts).ElementType, wantProtectedMember, outer));
case TypeKind.Pointer:
return(visitFunc(((IPointerTypeSymbol)ts).PointedAtType, wantProtectedMember, outer));
default:
break;
}
}
if (symbol.DeclaredAccessibility != Accessibility.Public)
{
return(false);
}
return(true);
}
protected override bool CanVisitApiCore(ISymbol symbol, bool wantProtectedMember, IFilterVisitor outer)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
if (!Inner.CanVisitApi(symbol, wantProtectedMember, outer))
{
return(false);
}
return(CanVisitCore(_configRule.ApiRules, symbol, wantProtectedMember, outer));
}
public virtual IFilterableElement acceptFilter(IFilterVisitor filter)
{
return(filter.VisitOperation(this));
}
private static bool CanVisitCore(INamedTypeSymbol symbol, Func<ISymbol, bool, IFilterVisitor, bool> visitFunc, bool wantProtectedMember, IFilterVisitor outer)
{
if (symbol.ContainingType != null)
{
switch (symbol.DeclaredAccessibility)
{
case Accessibility.Public:
return visitFunc(symbol.ContainingType, wantProtectedMember, outer);
case Accessibility.Protected:
case Accessibility.ProtectedOrInternal:
return wantProtectedMember && visitFunc(symbol.ContainingType, wantProtectedMember, outer);
default:
return false;
}
}
return symbol.DeclaredAccessibility == Accessibility.Public;
}
public abstract TResult AcceptVisitor <TArg, TResult>(IFilterVisitor <TArg, TResult> visitor, TArg arg);
public ConfigFilterVisitor(IFilterVisitor inner, string configFile)
: base(inner)
{
_configRule = ConfigFilterRule.Load(configFile);
}
protected override bool CanVisitAttributeCore(ISymbol symbol, bool wantProtectedMember, IFilterVisitor outer)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
if (!Inner.CanVisitAttribute(symbol, wantProtectedMember, outer))
{
return(false);
}
var symbolFilterData = RoslynFilterData.GetSymbolFilterData(symbol);
return(_configRule.CanVisitAttribute(symbolFilterData));
}
private static bool CanVisitCore(ISymbol symbol, Func<ISymbol, bool, IFilterVisitor, bool> visitFunc, bool wantProtectedMember, IFilterVisitor outer)
{
// check parent visibility
var current = symbol;
var parent = symbol.ContainingSymbol;
while (!(current is INamespaceSymbol) && parent != null)
{
if (!visitFunc(parent, wantProtectedMember, outer))
{
return false;
}
current = parent;
parent = parent.ContainingSymbol;
}
if (symbol.DeclaredAccessibility == Accessibility.NotApplicable)
{
return true;
}
if (symbol.IsImplicitlyDeclared)
{
return false;
}
var methodSymbol = symbol as IMethodSymbol;
if (methodSymbol != null)
{
return CanVisitCore(methodSymbol, visitFunc, wantProtectedMember, outer);
}
var propertySymbol = symbol as IPropertySymbol;
if (propertySymbol != null)
{
return CanVisitCore(propertySymbol, visitFunc, wantProtectedMember, outer);
}
var eventSymbol = symbol as IEventSymbol;
if (eventSymbol != null)
{
return CanVisitCore(eventSymbol, visitFunc, wantProtectedMember, outer);
}
var fieldSymbol = symbol as IFieldSymbol;
if (fieldSymbol != null)
{
return CanVisitCore(fieldSymbol, visitFunc, wantProtectedMember, outer);
}
var namedTypeSymbol = symbol as INamedTypeSymbol;
if (namedTypeSymbol != null)
{
return CanVisitCore(namedTypeSymbol, visitFunc, wantProtectedMember, outer);
}
var ts = symbol as ITypeSymbol;
if (ts != null)
{
switch (ts.TypeKind)
{
case TypeKind.Dynamic:
case TypeKind.TypeParameter:
return true;
case TypeKind.Unknown:
case TypeKind.Error:
return false;
case TypeKind.Array:
return visitFunc(((IArrayTypeSymbol)ts).ElementType, wantProtectedMember, outer);
case TypeKind.Pointer:
return visitFunc(((IPointerTypeSymbol)ts).PointedAtType, wantProtectedMember, outer);
default:
break;
}
}
if (symbol.DeclaredAccessibility != Accessibility.Public)
{
return false;
}
return true;
}
/// <inheritdoc />
public override void Accept(IFilterVisitor visitor)
{
visitor.VisitEqualityFilter(this);
}
public override void AcceptVisitor(IFilterVisitor visitor) => (visitor ?? throw new ArgumentNullException(nameof(visitor))).Visit(this);
public override TResult Accept <TArgument, TResult>(IFilterVisitor <TArgument, TResult> visitor, TArgument argument) => visitor.Visit(this, argument);
private static IEnumerable<AccessorDeclarationSyntax> GetPropertyAccessors(IPropertySymbol propertySymbol, IFilterVisitor filterVisitor)
{
var getAccessor = GetPropertyAccessorCore(propertySymbol, propertySymbol.GetMethod, SyntaxKind.GetAccessorDeclaration, SyntaxKind.GetKeyword, filterVisitor);
if (getAccessor != null)
{
yield return getAccessor;
}
var setAccessor = GetPropertyAccessorCore(propertySymbol, propertySymbol.SetMethod, SyntaxKind.SetAccessorDeclaration, SyntaxKind.SetKeyword, filterVisitor);
if (setAccessor != null)
{
yield return setAccessor;
}
}
public DelegatingFilterVisitor(IFilterVisitor inner)
{
Inner = inner;
}
private string GetEnumSyntax(INamedTypeSymbol symbol, IFilterVisitor filterVisitor) =>
RemoveBraces(
SyntaxFactory.EnumDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(GetTypeModifiers(symbol)),
SyntaxFactory.Identifier(symbol.Name),
GetEnumBaseTypeList(symbol),
new SeparatedSyntaxList<EnumMemberDeclarationSyntax>()
)
.NormalizeWhitespace()
.ToString()
);
public void Accept(IFilterVisitor renderFilterVisitor)
{
throw new NotImplementedException();
}
private string GetDelegateSyntax(INamedTypeSymbol symbol, IFilterVisitor filterVisitor) =>
SyntaxFactory.DelegateDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(
GetTypeModifiers(symbol)
),
GetTypeSyntax(symbol.DelegateInvokeMethod.ReturnType),
SyntaxFactory.Identifier(symbol.Name),
GetTypeParameters(symbol),
SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList(
from p in symbol.DelegateInvokeMethod.Parameters
select GetParameter(p, filterVisitor)
)
),
SyntaxFactory.List(
GetTypeParameterConstraints(symbol)
)
).NormalizeWhitespace().ToString();
public void Accept(IFilterVisitor renderFilterVisitor)
{
renderFilterVisitor.Visit(this);
}
private string GetOperatorSyntax(IMethodSymbol symbol, IFilterVisitor filterVisitor)
{
var operatorToken = GetOperatorToken(symbol);
if (operatorToken == null)
{
return "Not supported in c#";
}
else if (operatorToken.Value.Kind() == SyntaxKind.ImplicitKeyword || operatorToken.Value.Kind() == SyntaxKind.ExplicitKeyword)
{
return SyntaxFactory.ConversionOperatorDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(
GetMemberModifiers(symbol)
),
operatorToken.Value,
GetTypeSyntax(symbol.ReturnType),
SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList(
from p in symbol.Parameters
select GetParameter(p, filterVisitor)
)
),
null,
null
).NormalizeWhitespace().ToString();
}
else
{
return SyntaxFactory.OperatorDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(
GetMemberModifiers(symbol)
),
GetTypeSyntax(symbol.ReturnType),
operatorToken.Value,
SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList(
from p in symbol.Parameters
select GetParameter(p, filterVisitor)
)
),
null,
null
).NormalizeWhitespace().ToString();
}
}
public ConfigFilterVisitor(IFilterVisitor inner, ConfigFilterRule rule)
: base(inner)
{
_configRule = rule;
}
private string GetFieldSyntax(IFieldSymbol symbol, IFilterVisitor filterVisitor)
{
if (symbol.ContainingType.TypeKind == TypeKind.Enum)
{
return SyntaxFactory.EnumMemberDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.Identifier(symbol.Name),
GetDefaultValueClause(symbol)
).NormalizeWhitespace().ToString();
}
else
{
return SyntaxFactory.FieldDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(
GetMemberModifiers(symbol)
),
SyntaxFactory.VariableDeclaration(
GetTypeSyntax(symbol.Type),
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(symbol.Name),
null,
GetDefaultValueClause(symbol)
)
)
)
).NormalizeWhitespace().ToString().TrimEnd(';');
}
}
public virtual ImageMatrix Accept(IFilterVisitor <ImageMatrix> visitor)
{
return(visitor.Visit(this));
}
private string GetPropertySyntax(IPropertySymbol symbol, IFilterVisitor filterVisitor)
{
string result;
ExplicitInterfaceSpecifierSyntax eii = null;
if (symbol.ExplicitInterfaceImplementations.Length > 0)
{
eii = SyntaxFactory.ExplicitInterfaceSpecifier(SyntaxFactory.ParseName(GetEiiContainerTypeName(symbol, filterVisitor)));
}
if (symbol.IsIndexer)
{
result = SyntaxFactory.IndexerDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(GetMemberModifiers(symbol)),
GetTypeSyntax(symbol.Type),
eii,
SyntaxFactory.BracketedParameterList(
SyntaxFactory.SeparatedList(
from p in symbol.Parameters
select GetParameter(p, filterVisitor))),
SyntaxFactory.AccessorList(SyntaxFactory.List(GetPropertyAccessors(symbol, filterVisitor))))
.NormalizeWhitespace()
.ToString();
}
else
{
result = SyntaxFactory.PropertyDeclaration(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(GetMemberModifiers(symbol)),
GetTypeSyntax(symbol.Type),
eii,
SyntaxFactory.Identifier(GetMemberName(symbol, filterVisitor)),
SyntaxFactory.AccessorList(SyntaxFactory.List(GetPropertyAccessors(symbol, filterVisitor))))
.NormalizeWhitespace()
.ToString();
}
result = Regex.Replace(result, @"\s*\{\s*get;\s*set;\s*}\s*$", " { get; set; }");
result = Regex.Replace(result, @"\s*\{\s*get;\s*}\s*$", " { get; }");
result = Regex.Replace(result, @"\s*\{\s*set;\s*}\s*$", " { set; }");
result = Regex.Replace(result, @"\s*\{\s*get;\s*protected set;\s*}\s*$", " { get; protected set; }");
result = Regex.Replace(result, @"\s*\{\s*protected get;\s*set;\s*}\s*$", " { protected get; set; }");
return result;
}
public CachedFilterVisitor(IFilterVisitor inner) : base(inner)
{
_cache = new Dictionary <CachedKey, bool>();
_attributeCache = new Dictionary <CachedKey, bool>();
}
private static string GetMemberName(IPropertySymbol symbol, IFilterVisitor filterVisitor)
{
string name = symbol.Name;
if (symbol.ExplicitInterfaceImplementations.Length == 0)
{
return symbol.Name;
}
for (int i = 0; i < symbol.ExplicitInterfaceImplementations.Length; i++)
{
if (filterVisitor.CanVisitApi(symbol.ExplicitInterfaceImplementations[i]))
{
return symbol.ExplicitInterfaceImplementations[i].Name;
}
}
Debug.Fail("Should not be here!");
return symbol.Name;
}
protected override bool CanVisitAttributeCore(ISymbol symbol, bool wantProtectedMember, IFilterVisitor outer)
{
var key = new CachedKey(symbol, wantProtectedMember);
if (_attributeCache.TryGetValue(key, out bool result))
{
return(result);
}
result = _attributeCache[key] = Inner.CanVisitAttribute(symbol, wantProtectedMember, outer);
return(result);
}
private static ParameterSyntax GetParameter(IParameterSymbol p, IFilterVisitor filterVisitor, bool isThisParameter = false)
{
return SyntaxFactory.Parameter(
GetAttributes(p, filterVisitor, true),
SyntaxFactory.TokenList(GetParameterModifiers(p, isThisParameter)),
GetTypeSyntax(p.Type),
SyntaxFactory.Identifier(p.Name),
GetDefaultValueClause(p));
}
/// <summary> /// Accepts a visitor and performs double-dispatch. /// </summary> /// <param name="visitor">The visitor, never null.</param> public abstract void Accept(IFilterVisitor visitor);
public static IFilterVisitor WithCache(this IFilterVisitor fv)
{
return(new CachedFilterVisitor(fv));
}
public ConfigFilterVisitor(IFilterVisitor inner, string configFile)
: base(inner)
{
_configFile = configFile;
_configRule = LoadRules(configFile);
}
/// <inheritdoc />
public override void Accept(IFilterVisitor visitor)
{
visitor.VisitRegexFilter(this);
}
private string GetPropertySyntax(IPropertySymbol symbol, IFilterVisitor filterVisitor)
{
return SyntaxFactory.PropertyStatement(
GetAttributes(symbol, filterVisitor),
SyntaxFactory.TokenList(
GetMemberModifiers(symbol)
),
SyntaxFactory.Identifier(symbol.MetadataName),
GetParamerterList(symbol),
SyntaxFactory.SimpleAsClause(
GetTypeSyntax(symbol.Type)
),
null,
GetImplementsClause(symbol, filterVisitor)
).NormalizeWhitespace().ToString();
}
