public static void Free(UseConstantInsteadOfFieldWalker walker)
{
walker.FieldSymbol = null;
walker.SemanticModel = null;
walker.CancellationToken = default;
walker.CanBeConvertedToConstant = true;
_cachedInstance = walker;
}
public static void Free(UseConstantInsteadOfFieldWalker walker)
{
walker.FieldSymbol = null;
walker.SemanticModel = null;
walker.CancellationToken = default;
walker.IsUsedInRefOrOutArgument = false;
_cachedInstance = walker;
}
public static UseConstantInsteadOfFieldWalker GetInstance()
{
UseConstantInsteadOfFieldWalker walker = _cachedInstance;
if (walker != null)
{
_cachedInstance = null;
return(walker);
}
else
{
return(new UseConstantInsteadOfFieldWalker());
}
}
public static UseConstantInsteadOfFieldWalker GetInstance()
{
UseConstantInsteadOfFieldWalker walker = _cachedInstance;
if (walker != null)
{
Debug.Assert(walker.FieldSymbol == null);
Debug.Assert(walker.SemanticModel == null);
Debug.Assert(walker.CancellationToken == default);
_cachedInstance = null;
return(walker);
}
return(new UseConstantInsteadOfFieldWalker());
}
public static bool IsFixable(
FieldDeclarationSyntax fieldDeclaration,
SemanticModel semanticModel,
bool onlyPrivate = false,
CancellationToken cancellationToken = default)
{
bool isStatic = false;
bool isReadOnly = false;
foreach (SyntaxToken modifier in fieldDeclaration.Modifiers)
{
switch (modifier.Kind())
{
case SyntaxKind.ConstKeyword:
case SyntaxKind.NewKeyword:
{
return(false);
}
case SyntaxKind.PublicKeyword:
case SyntaxKind.InternalKeyword:
case SyntaxKind.ProtectedKeyword:
{
if (onlyPrivate)
{
return(false);
}
break;
}
case SyntaxKind.StaticKeyword:
{
isStatic = true;
break;
}
case SyntaxKind.ReadOnlyKeyword:
{
isReadOnly = true;
break;
}
}
}
if (!isStatic)
{
return(false);
}
if (!isReadOnly)
{
return(false);
}
SeparatedSyntaxList <VariableDeclaratorSyntax> declarators = fieldDeclaration.Declaration.Variables;
VariableDeclaratorSyntax firstDeclarator = declarators[0];
var fieldSymbol = (IFieldSymbol)semanticModel.GetDeclaredSymbol(firstDeclarator, cancellationToken);
if (fieldSymbol == null)
{
return(false);
}
if (!fieldSymbol.Type.SupportsConstantValue())
{
return(false);
}
foreach (VariableDeclaratorSyntax declarator in declarators)
{
ExpressionSyntax value = declarator.Initializer?.Value;
if (value == null)
{
return(false);
}
if (!semanticModel.HasConstantValue(value, cancellationToken))
{
return(false);
}
}
foreach (IMethodSymbol constructorSymbol in fieldSymbol.ContainingType.StaticConstructors)
{
foreach (SyntaxReference syntaxReference in constructorSymbol.DeclaringSyntaxReferences)
{
if (syntaxReference.SyntaxTree != fieldDeclaration.SyntaxTree)
{
return(false);
}
var constructorDeclaration = (ConstructorDeclarationSyntax)syntaxReference.GetSyntax(cancellationToken);
BlockSyntax body = constructorDeclaration.Body;
if (body != null)
{
UseConstantInsteadOfFieldWalker walker = UseConstantInsteadOfFieldWalker.GetInstance();
walker.FieldSymbol = fieldSymbol;
walker.SemanticModel = semanticModel;
walker.CancellationToken = cancellationToken;
walker.VisitBlock(body);
bool canBeConvertedToConstant = walker.CanBeConvertedToConstant;
UseConstantInsteadOfFieldWalker.Free(walker);
if (!canBeConvertedToConstant)
{
return(false);
}
}
}
}
return(true);
}
