private static bool EqualsValueClauseNotSuitableForVar(
SyntaxToken identifier,
TypeSyntax simpleName,
EqualsValueClauseSyntax equalsValueClause,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
// var cannot be assigned null
if (equalsValueClause.IsKind(SyntaxKind.NullLiteralExpression))
{
return true;
}
var type = semanticModel.GetTypeInfo(simpleName, cancellationToken).Type;
// the variable cannot be initialized to a method group or an anonymous function
if (type != null &&
type.TypeKind == TypeKind.Delegate)
{
return true;
}
var initializerType = semanticModel.GetTypeInfo(equalsValueClause.Value, cancellationToken).Type;
if (!type.Equals(initializerType))
{
return true;
}
// The assign expression in the initializer cannot be the same symbol as the i
var possibleSameLocals = equalsValueClause.DescendantNodesAndSelf().Where(n => n.Kind() == SyntaxKind.IdentifierName && ((IdentifierNameSyntax)n).Identifier.ValueText.Equals(identifier.ValueText));
var anyUse = possibleSameLocals.Any(n =>
{
var symbol = semanticModel.GetSymbolInfo(n, cancellationToken).Symbol;
if (symbol != null && symbol.Kind == SymbolKind.Local)
{
return true;
}
return false;
});
if (anyUse)
{
return true;
}
return false;
}
/// <summary>
/// Analyzes the assignment expression and rejects a given declaration if it is unsuitable for implicit typing.
/// </summary>
/// <returns>
/// false, if implicit typing cannot be used.
/// true, otherwise.
/// </returns>
protected override bool AssignmentSupportsStylePreference(SyntaxToken identifier, TypeSyntax typeName, EqualsValueClauseSyntax initializer, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken)
{
var expression = GetInitializerExpression(initializer);
// var cannot be assigned null
if (expression.IsKind(SyntaxKind.NullLiteralExpression))
{
return false;
}
// cannot use implicit typing on method group, anonymous function or on dynamic
var declaredType = semanticModel.GetTypeInfo(typeName, cancellationToken).Type;
if (declaredType != null &&
(declaredType.TypeKind == TypeKind.Delegate || declaredType.TypeKind == TypeKind.Dynamic))
{
return false;
}
// variables declared using var cannot be used further in the same initialization expression.
if (initializer.DescendantNodesAndSelf()
.Where(n => (n as IdentifierNameSyntax)?.Identifier.ValueText.Equals(identifier.ValueText) == true)
.Any(n => semanticModel.GetSymbolInfo(n, cancellationToken).Symbol?.IsKind(SymbolKind.Local) == true))
{
return false;
}
// Get the conversion that occurred between the expression's type and type implied by the expression's context
// and filter out implicit conversions. If an implicit conversion (other than identity) exists
// and if we're replacing the declaration with 'var' we'd be changing the semantics by inferring type of
// initializer expression and thereby losing the conversion.
var conversion = semanticModel.GetConversion(expression, cancellationToken);
if (conversion.Exists && conversion.IsImplicit && !conversion.IsIdentity)
{
return false;
}
// final check to compare type information on both sides of assignment.
var initializerType = semanticModel.GetTypeInfo(expression, cancellationToken).Type;
return declaredType.Equals(initializerType);
}
