private CSharpSyntaxNode GetInitializerFromNameAndType(ITypeSymbol typeSymbol,
ModifiedIdentifierSyntax name, CSharpSyntaxNode initializer)
{
if (!SyntaxTokenExtensions.IsKind(name.Nullable, SyntaxKind.None))
{
if (typeSymbol.IsArrayType())
{
initializer = null;
}
}
var rankSpecifiers = ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds, false);
if (rankSpecifiers.Count > 0)
{
var rankSpecifiersWithSizes = ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds);
if (!rankSpecifiersWithSizes.SelectMany(ars => ars.Sizes).OfType <OmittedArraySizeExpressionSyntax>().Any())
{
var arrayTypeSyntax = (ArrayTypeSyntax)CsSyntaxGenerator.TypeExpression(typeSymbol);
arrayTypeSyntax = arrayTypeSyntax.WithRankSpecifiers(rankSpecifiersWithSizes);
initializer = SyntaxFactory.ArrayCreationExpression(arrayTypeSyntax);
}
}
return(initializer);
}
public TypeSyntax GetTypeSyntax(ITypeSymbol typeSymbol, bool useImplicitType = false)
{
if (useImplicitType || typeSymbol == null)
{
return(CreateVarTypeName());
}
return((TypeSyntax)CsSyntaxGenerator.TypeExpression(typeSymbol));
}
public TypeSyntax GetTypeSyntax(ITypeSymbol typeSymbol, bool useImplicitType = false)
{
if (useImplicitType || typeSymbol == null)
{
return(ValidSyntaxFactory.VarType);
}
var syntax = (TypeSyntax)CsSyntaxGenerator.TypeExpression(typeSymbol);
return(WithDeclarationCasing(syntax, typeSymbol));
}
private TypeSyntax GetFuncTypeSyntax(IMethodSymbol method)
{
var parameters = method.Parameters.Select(p => p.Type).ToArray();
if (method.ReturnsVoid)
{
return(parameters.Any() ? (TypeSyntax)CsSyntaxGenerator.GenericName(nameof(Action), parameters)
: SyntaxFactory.ParseTypeName("Action"));
}
parameters = parameters.Concat(new[] { method.ReturnType }).ToArray();
return((TypeSyntax)CsSyntaxGenerator.GenericName(nameof(Func <object>), parameters));
}
public (IReadOnlyCollection <VariableDeclarationSyntax> Variables, IReadOnlyCollection <CSharpSyntaxNode> Methods) SplitVariableDeclarations(
VariableDeclaratorSyntax declarator, bool preferExplicitType = false)
{
var vbInitValue = GetInitializerToConvert(declarator);
var initializerOrMethodDecl = vbInitValue?.Accept(TriviaConvertingExpressionVisitor);
var vbInitializerType = vbInitValue != null?_semanticModel.GetTypeInfo(vbInitValue).Type : null;
bool requireExplicitTypeForAll = false;
IMethodSymbol initSymbol = null;
if (vbInitValue != null)
{
var vbInitConstantValue = _semanticModel.GetConstantValue(vbInitValue);
var vbInitIsNothingLiteral = vbInitConstantValue.HasValue && vbInitConstantValue.Value == null;
preferExplicitType |= vbInitializerType != null && vbInitializerType.HasCsKeyword();
initSymbol = _semanticModel.GetSymbolInfo(vbInitValue).Symbol as IMethodSymbol;
bool isAnonymousFunction = initSymbol?.IsAnonymousFunction() == true;
requireExplicitTypeForAll = vbInitIsNothingLiteral || isAnonymousFunction;
}
var csVars = new Dictionary <string, VariableDeclarationSyntax>();
var csMethods = new List <CSharpSyntaxNode>();
foreach (var name in declarator.Names)
{
var declaredSymbol = _semanticModel.GetDeclaredSymbol(name);
var declaredSymbolType = declaredSymbol.GetSymbolType();
var requireExplicitType = requireExplicitTypeForAll || vbInitializerType != null && !Equals(declaredSymbolType, vbInitializerType);
var csTypeSyntax = (TypeSyntax)CsSyntaxGenerator.TypeExpression(declaredSymbolType);
bool isField = declarator.Parent.IsKind(SyntaxKind.FieldDeclaration);
EqualsValueClauseSyntax equalsValueClauseSyntax;
if (GetInitializerFromNameAndType(declaredSymbolType, name, initializerOrMethodDecl) is ExpressionSyntax adjustedInitializerExpr)
{
var convertedInitializer = vbInitValue != null?TypeConversionAnalyzer.AddExplicitConversion(vbInitValue, adjustedInitializerExpr) : adjustedInitializerExpr;
equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(convertedInitializer);
}
else if (isField || _semanticModel.IsDefinitelyAssignedBeforeRead(declaredSymbol, name))
{
equalsValueClauseSyntax = null;
}
else
{
// VB initializes variables to their default
equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(csTypeSyntax));
}
var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax);
string k = declaredSymbolType.GetFullMetadataName();
if (csVars.TryGetValue(k, out var decl))
{
csVars[k] = decl.AddVariables(v);
}
else
{
if (initializerOrMethodDecl == null || initializerOrMethodDecl is ExpressionSyntax)
{
bool useVar = equalsValueClauseSyntax != null && !preferExplicitType && !requireExplicitType;
var typeSyntax = initSymbol == null || !initSymbol.IsAnonymousFunction()
? GetTypeSyntax(declaredSymbolType, useVar)
: GetFuncTypeSyntax(initSymbol);
csVars[k] = SyntaxFactory.VariableDeclaration(typeSyntax, SyntaxFactory.SingletonSeparatedList(v));
}
else
{
csMethods.Add(initializerOrMethodDecl);
}
}
}
return(csVars.Values, csMethods);
}
