/// <summary>
/// Evaluate expression that contains a list of assignment.
/// </summary>
/// <param name="declaration"></param>
/// <param name="state"></param>
private VariableState VisitVariableDeclaration(VariableDeclaratorSyntax declaration, ExecutionState state)
{
VariableState lastState = new VariableState(declaration, VariableTaint.UNKNOWN);
foreach (var variable in declaration.Names)
{
var identifier = variable.Identifier;
var initializer = declaration.Initializer;
if (initializer is EqualsValueSyntax)
{
EqualsValueSyntax equalsClause = initializer;
VariableState varState = VisitExpression(equalsClause.Value, state);
//varState.SetType(lastState.type);
state.AddNewValue(ResolveIdentifier(identifier), varState);
lastState = varState;
}
if (declaration.AsClause is AsNewClauseSyntax)
{
var newClause = (AsNewClauseSyntax)declaration.AsClause;
VariableState varState = VisitExpression(newClause.NewExpression, state);
state.AddNewValue(ResolveIdentifier(identifier), varState);
lastState = varState;
}
}
return(lastState);
}
public override SyntaxNode GetDefaultValueForAnOptionalParameter(SyntaxNode declNode, int paramIndex)
{
if (declNode == null)
{
return(null);
}
var methodDecl = (MethodBlockBaseSyntax)declNode;
ParameterListSyntax paramList = methodDecl.BlockStatement.ParameterList;
if (paramIndex >= paramList.Parameters.Count)
{
return(null);
}
EqualsValueSyntax equalsValueNode = paramList.Parameters[paramIndex].Default;
if (equalsValueNode != null)
{
return(equalsValueNode.Value);
}
return(null);
}
private VariableState VisitVariableDeclaration(VariableDeclaratorSyntax declaration, ExecutionState state)
{
VariableState lastState = new VariableState(declaration, VariableTaint.UNKNOWN);
var identifier = declaration.GetFirstToken();
var initializer = declaration.Initializer;
if (initializer is EqualsValueSyntax)
{
EqualsValueSyntax equalsClause = initializer;
VariableState varState = VisitExpression(equalsClause.Value, state);
state.AddNewValue(ResolveIdentifier(identifier), varState);
lastState = varState;
}
return(lastState);
}
private VariableDeclaratorSyntax ConvertToVariableDeclarator(CSS.PropertyDeclarationSyntax des)
{
var id = GetVbPropertyBackingFieldName(des);
var ids = SyntaxFactory.SingletonSeparatedList(SyntaxFactory.ModifiedIdentifier(id));
TypeSyntax typeSyntax;
if (des.Type.IsVar)
{
var typeSymbol = ModelExtensions.GetSymbolInfo(_semanticModel, des.Type).ExtractBestMatch <ITypeSymbol>();
typeSyntax = typeSymbol?.ToVbSyntax(_semanticModel, des.Type);
}
else
{
typeSyntax = (TypeSyntax)des.Type.Accept(_nodesVisitor);
}
var simpleAsClauseSyntax = typeSyntax != null?SyntaxFactory.SimpleAsClause(typeSyntax) : null; //Gracefully degrade when no type information available
EqualsValueSyntax equalsValueSyntax = null;
return(SyntaxFactory.VariableDeclarator(ids, simpleAsClauseSyntax, equalsValueSyntax));
}
public override VisualBasicSyntaxNode VisitParameter(CSS.ParameterSyntax node)
{
var id = SyntaxFactory.Identifier(node.Identifier.ValueText, SyntaxFacts.IsKeywordKind(node.Identifier.Kind()), node.Identifier.GetIdentifierText(), TypeCharacter.None);
EqualsValueSyntax @default = null;
if (node.Default != null)
{
@default = SyntaxFactory.EqualsValue((ExpressionSyntax)node.Default?.Value.Accept(this));
}
AttributeListSyntax[] newAttributes;
var modifiers = ConvertModifiers(node.Modifiers, TokenContext.Member);
if (modifiers.Count == 0)
{
modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword));
newAttributes = new AttributeListSyntax[0];
}
else if (node.Modifiers.Any(m => m.IsKind(CS.SyntaxKind.OutKeyword)))
{
newAttributes = new[] {
SyntaxFactory.AttributeList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Attribute(SyntaxFactory.ParseTypeName("Out"))
)
)
};
}
else
{
newAttributes = new AttributeListSyntax[0];
}
return(SyntaxFactory.Parameter(
SyntaxFactory.List(newAttributes.Concat(node.AttributeLists.Select(a => (AttributeListSyntax)a.Accept(this)))),
modifiers,
SyntaxFactory.ModifiedIdentifier(id),
SyntaxFactory.SimpleAsClause((TypeSyntax)node.Type.Accept(this)),
@default
));
}
private ImmutableArray <SymbolDisplayPart> GetInitializerParts(
ImmutableArray <SymbolDisplayPart> .Builder parts, EqualsValueSyntax equalsValue)
{
// TODO: use Microsoft.CodeAnalysis.Classification.Classifier to get parts from equalsValue
return(parts.TryMoveToImmutable());
}
protected override async Task <ImmutableArray <SymbolDisplayPart> > GetInitializerPartsAsync(ISymbol symbol)
{
object evaluatedValue = null;
EqualsValueSyntax initializer = null;
switch (symbol)
{
case IFieldSymbol field:
evaluatedValue = field.ConstantValue;
var fieldDeclarator = await symbol.GetDeclarationAsync <VariableDeclaratorSyntax>(CancellationToken);
if (fieldDeclarator is null)
{
var enumMemberDeclaration = await symbol.GetDeclarationAsync <EnumMemberDeclarationSyntax>(CancellationToken);
if (!(enumMemberDeclaration is null))
{
initializer = enumMemberDeclaration.Initializer;
}
}
else
{
initializer = fieldDeclarator.Initializer;
}
break;
case ILocalSymbol local:
evaluatedValue = local.ConstantValue;
var localDeclarator = await symbol.GetDeclarationAsync <VariableDeclaratorSyntax>(CancellationToken);
if (!(localDeclarator is null))
{
initializer = localDeclarator.Initializer;
}
break;
case IParameterSymbol parameter:
evaluatedValue = parameter.ExplicitDefaultValue;
var parameterSyntax = await symbol.GetDeclarationAsync <ParameterSyntax>(CancellationToken);
if (!(parameterSyntax is null))
{
initializer = parameterSyntax.Default;
}
break;
}
var builder = ImmutableArray.CreateBuilder <SymbolDisplayPart>();
if (!(evaluatedValue is null))
{
if (evaluatedValue is string str)
{
builder.Add(new SymbolDisplayPart(SymbolDisplayPartKind.StringLiteral, null, $"\"{str}\""));
}
else if (evaluatedValue.IsNumber())
{
builder.Add(new SymbolDisplayPart(SymbolDisplayPartKind.NumericLiteral, null, evaluatedValue.ToString()));
}
}
if (initializer is null)
{
return(builder.TryMoveToImmutable());
}
return(GetInitializerParts(builder, initializer));
}
