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(); }