public ExpressionResult Resolve(Document document, ExpressionSyntax expressionSyntax, IEnumerable <SyntaxNode> nodes, SemanticModel semanticModel, ExpressionResolver expressionResolverInstance)
{
using (MiniProfiler.Current.Step(nameof(InvocationStrategy)))
{
var invocationExpression = expressionSyntax as InvocationExpressionSyntax;
var optionalConst = semanticModel?.GetConstantValue(expressionSyntax);
if (optionalConst?.HasValue ?? false)
{
return(new ExpressionResult
{
CanBeUsedAsQuery = false,
ExpressionText = expressionSyntax.ToString(),
IsSolved = true,
TextResult = optionalConst.Value.Value.ToString(),
});
}
var nextInvocationExpression = invocationExpression.Expression;
if (nextInvocationExpression is MemberAccessExpressionSyntax)
{
var knowMethodFactory = new KnownMethodResolverFactory(invocationExpression, nextInvocationExpression, expressionResolverInstance, document, nodes, semanticModel);
return(knowMethodFactory.GetResolver().Resolve());
}
return(new ExpressionResult
{
IsSolved = false,
UnresolvableReason = $"Child expression is not {nameof(MemberAccessExpressionSyntax)}",
TextResult = "",
});
}
}
public static bool IsEmptyStringExpression(
ExpressionSyntax expression,
SemanticModel semanticModel,
CancellationToken cancellationToken = default)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
if (semanticModel == null)
{
throw new ArgumentNullException(nameof(semanticModel));
}
SyntaxKind kind = expression.Kind();
if (kind == SyntaxKind.StringLiteralExpression)
{
return(((LiteralExpressionSyntax)expression).Token.ValueText.Length == 0);
}
else if (kind == SyntaxKind.InterpolatedStringExpression)
{
return(!((InterpolatedStringExpressionSyntax)expression).Contents.Any());
}
else if (kind == SyntaxKind.SimpleMemberAccessExpression)
{
var memberAccess = (MemberAccessExpressionSyntax)expression;
if (memberAccess.Name?.Identifier.ValueText == "Empty")
{
ISymbol symbol = semanticModel.GetSymbol(memberAccess, cancellationToken);
if (symbol?.Kind == SymbolKind.Field)
{
var fieldSymbol = (IFieldSymbol)symbol;
if (SymbolUtility.IsPublicStaticReadOnly(fieldSymbol, "Empty") &&
fieldSymbol.ContainingType?.SpecialType == SpecialType.System_String &&
fieldSymbol.Type.IsString())
{
return(true);
}
}
}
}
Optional <object> optional = semanticModel.GetConstantValue(expression, cancellationToken);
if (optional.HasValue)
{
var value = optional.Value as string;
return(value?.Length == 0);
}
return(false);
}
public static bool IsEmptyString(
ExpressionSyntax expression,
SemanticModel semanticModel,
CancellationToken cancellationToken = default(CancellationToken))
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
if (semanticModel == null)
{
throw new ArgumentNullException(nameof(semanticModel));
}
SyntaxKind kind = expression.Kind();
if (kind == SyntaxKind.StringLiteralExpression)
{
return(((LiteralExpressionSyntax)expression).Token.ValueText.Length == 0);
}
else if (kind == SyntaxKind.SimpleMemberAccessExpression)
{
var memberAccess = (MemberAccessExpressionSyntax)expression;
if (memberAccess.Name?.Identifier.ValueText == "Empty")
{
ISymbol symbol = semanticModel.GetSymbol(memberAccess, cancellationToken);
if (symbol?.IsField() == true)
{
var fieldSymbol = (IFieldSymbol)symbol;
if (string.Equals(fieldSymbol.Name, "Empty", StringComparison.Ordinal) &&
fieldSymbol.ContainingType?.IsString() == true &&
fieldSymbol.IsPublic() &&
fieldSymbol.IsStatic &&
fieldSymbol.IsReadOnly &&
fieldSymbol.Type.IsString())
{
return(true);
}
}
}
}
Optional <object> optional = semanticModel.GetConstantValue(expression, cancellationToken);
if (optional.HasValue)
{
var value = optional.Value as string;
return(value?.Length == 0);
}
return(false);
}
public static bool IsConstant(this ExpressionSyntax expression, SemanticModel semanticModel)
{
if (expression == null)
{
return(false);
}
return(expression.RemoveParentheses().IsAnyKind(LiteralSyntaxKinds) ||
semanticModel.GetConstantValue(expression).HasValue);
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, ExpressionSyntax expression)
{
if (expression is LiteralExpressionSyntax)
{
return;
}
if (CSharpUtility.IsStringLiteralConcatenation(expression as BinaryExpressionSyntax))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var optional = default(Optional <object>);
ISymbol symbol = semanticModel.GetSymbol(expression, context.CancellationToken);
if (symbol?.IsErrorType() != false)
{
return;
}
if (symbol is IFieldSymbol fieldSymbol)
{
if (!fieldSymbol.HasConstantValue)
{
return;
}
if (fieldSymbol.ContainingType?.TypeKind == TypeKind.Enum)
{
return;
}
}
else if (symbol is ILocalSymbol localSymbol)
{
if (!localSymbol.HasConstantValue)
{
return;
}
}
else
{
optional = semanticModel.GetConstantValue(expression, context.CancellationToken);
if (!optional.HasValue)
{
return;
}
}
context.RegisterRefactoring(
"Inline constant value",
ct => RefactorAsync(context.Document, expression, symbol, optional, semanticModel, ct),
RefactoringDescriptors.InlineConstantValue);
}
private bool IsZeroLengthArrayAllocationCSharp(SyntaxToken token)
{
var arrayCreationExpression = token.Parent as CS.Syntax.ArrayCreationExpressionSyntax;
if (arrayCreationExpression == null)
{
return(false);
}
var arrayType = arrayCreationExpression.Type;
if (arrayType == null || arrayType.IsMissing)
{
return(false);
}
if (arrayType.RankSpecifiers.Count != 1)
{
return(false);
}
var specifier = arrayType.RankSpecifiers[0] as CS.Syntax.ArrayRankSpecifierSyntax;
if (specifier == null)
{
return(false);
}
if (specifier.Rank != 1 || specifier.Sizes.Count != 1)
{
return(false);
}
var sizeExpression = specifier.Sizes[0];
if (sizeExpression == null)
{
return(false);
}
if (sizeExpression is CS.Syntax.OmittedArraySizeExpressionSyntax &&
arrayCreationExpression.Initializer != null &&
!arrayCreationExpression.Initializer.IsMissing &&
arrayCreationExpression.Initializer.Expressions.Count == 0)
{
return(true);
}
var value = SemanticModel.GetConstantValue(sizeExpression);
if (!value.HasValue || !(value.Value is int))
{
return(false);
}
return((int)value.Value == 0);
}
private string GetStatus(INamedTypeSymbol classSymbol, SyntaxNode root, SemanticModel model, DiagnosticDescriptor descriptor)
{
// Some analyzers use multiple descriptors. We analyze the first one and hope that
// thats enough.
var members = classSymbol.GetMembers().Where(x => x.Name.Contains("Descriptor")).ToArray();
foreach (var member in members)
{
ObjectCreationExpressionSyntax initializer;
SyntaxNode node = root.FindNode(member.Locations.FirstOrDefault().SourceSpan);
if (node != null)
{
initializer = (node as PropertyDeclarationSyntax)?.Initializer?.Value as ObjectCreationExpressionSyntax;
if (initializer == null)
{
initializer = (node as VariableDeclaratorSyntax)?.Initializer?.Value as ObjectCreationExpressionSyntax;
if (initializer == null)
{
continue;
}
}
}
else
{
continue;
}
var firstArgument = initializer.ArgumentList.Arguments[0];
string constantValue = (string)model.GetConstantValue(firstArgument.Expression).Value;
if (constantValue != descriptor.Id)
{
continue;
}
// We use the fact that the only parameter that returns a boolean is the one we are interested in
var enabledByDefaultParameter = from argument in initializer.ArgumentList.Arguments
where Equals(model.GetTypeInfo(argument.Expression).Type, _booleanType)
select argument.Expression;
var parameter = enabledByDefaultParameter.FirstOrDefault();
string parameterString = parameter.ToString();
var analyzerConstantLength = "AnalyzerConstants.".Length;
if (parameterString.Length < analyzerConstantLength)
{
return(parameterString);
}
return(parameter.ToString().Substring(analyzerConstantLength));
}
return("Unknown");
}
private static bool IsZeroConstantValue(this SemanticModel semanticModel, ExpressionSyntax expression, CancellationToken cancellationToken = default(CancellationToken))
{
Optional <object> optional = semanticModel.GetConstantValue(expression, cancellationToken);
if (optional.HasValue)
{
object value = optional.Value;
if (value is int)
{
return((int)value == 0);
}
else if (value is uint)
{
return((uint)value == 0);
}
else if (value is sbyte)
{
return((sbyte)value == 0);
}
else if (value is byte)
{
return((byte)value == 0);
}
else if (value is short)
{
return((short)value == 0);
}
else if (value is ushort)
{
return((ushort)value == 0);
}
else if (value is long)
{
return((long)value == 0);
}
else if (value is ulong)
{
return((ulong)value == 0);
}
else if (value is float)
{
return((float)value == 0);
}
else if (value is double)
{
return((double)value == 0);
}
else if (value is decimal)
{
return((decimal)value == 0);
}
}
return(false);
}
private static int GetConstantIntFromExpression(ExpressionSyntax expression, SemanticModel semanticModel)
{
var constantValue = semanticModel.GetConstantValue(expression);
if (!constantValue.HasValue)
{
throw new ShaderGenerationException("Expression did not contain a constant value: " + expression.ToFullString());
}
return((int)constantValue.Value);
}
private static void CreateExpressions(ExpressionSyntax ifExpression, ExpressionSyntax elseExpression,
ITypeSymbol ifType, ITypeSymbol elseType,
ITypeSymbol ifConvertedType, ITypeSymbol elseConvertedType,
TypeSyntax typeSyntax, SemanticModel semanticModel,
out ExpressionSyntax trueExpression, out ExpressionSyntax falseExpression)
{
var isNullable = false;
if (ifConvertedType?.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
{
var constValue = semanticModel.GetConstantValue(ifExpression);
trueExpression = constValue.HasValue && constValue.Value == null
? SyntaxFactory.CastExpression(typeSyntax, ifExpression)
: ifExpression;
isNullable = true;
}
else
{
trueExpression = ifExpression;
}
if (elseConvertedType?.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
{
var constValue = semanticModel.GetConstantValue(elseExpression);
falseExpression = constValue.HasValue && constValue.Value == null
? SyntaxFactory.CastExpression(typeSyntax, elseExpression)
: elseExpression;
isNullable = true;
}
else
{
falseExpression = elseExpression;
}
if (!elseType.HasImplicitNumericConversion(ifType) &&
!IsEnumAndZero(ifType, elseExpression) &&
!IsEnumAndZero(elseType, ifExpression) &&
(!isNullable && !ifType.CanBeAssignedTo(elseType) || !elseType.CanBeAssignedTo(ifType)) &&
ifType != ifConvertedType)
{
trueExpression = CastToConvertedType(ifExpression, ifConvertedType);
}
}
public static bool NodeHasConstantValueNull(SyntaxNode node, SemanticModel model)
{
if (node == null || model == null)
{
return(false);
}
Optional <object> value = model.GetConstantValue(node);
return(value.HasValue && value.Value == null);
}
public static string GetConstantAttribute(
this AttributeSyntax attribute,
string argumentName,
SemanticModel semanticModel)
{
var expression = attribute.GetArgument <ExpressionSyntax>(argumentName);
Optional <object> value = semanticModel.GetConstantValue(expression);
return(value.HasValue ? value.Value.ToString() : null);
}
public static bool IsBooleanConstant(this SyntaxNode syntaxNode, SemanticModel semanticModel)
{
if (syntaxNode is MemberAccessExpressionSyntax ||
syntaxNode is IdentifierNameSyntax)
{
var constant = semanticModel.GetConstantValue(syntaxNode);
return(constant.HasValue && constant.Value is bool);
}
return(false);
}
private static string GetGuidMetadataConstantValue(this AttributeArgumentSyntax syntax, SemanticModel semanticModel)
{
if (syntax == null)
{
return(null);
}
var constantValue = semanticModel.GetConstantValue(syntax.Expression);
return(constantValue.Value?.ToString());
}
private static bool IsStringLiteral(ExpressionSyntax expression, SemanticModel semanticModel)
{
if (expression == null)
{
return(false);
}
var constant = semanticModel.GetConstantValue(expression);
return(constant.HasValue && constant.Value is string);
}
public async Task <(IReadOnlyCollection <VariableDeclarationSyntax> Variables, IReadOnlyCollection <CSharpSyntaxNode> Methods)> SplitVariableDeclarations(
VariableDeclaratorSyntax declarator, bool preferExplicitType = false)
{
var vbInitValue = GetInitializerToConvert(declarator);
var initializerOrMethodDecl = await vbInitValue.AcceptAsync(TriviaConvertingExpressionVisitor);
var vbInitializerType = vbInitValue != null?_semanticModel.GetTypeInfo(vbInitValue).Type : null;
bool requireExplicitTypeForAll = declarator.Names.Count > 1;
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 equalsValueClauseSyntax = await ConvertEqualsValueClauseSyntax(declarator, name, vbInitValue, declaredSymbolType, declaredSymbol, initializerOrMethodDecl);
var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax);
string k = declaredSymbolType?.GetFullMetadataName() ?? name.ToString();//Use likely unique key if the type symbol isn't available
if (csVars.TryGetValue(k, out var decl))
{
csVars[k] = decl.AddVariables(v);
continue;
}
if (initializerOrMethodDecl == null || initializerOrMethodDecl is ExpressionSyntax)
{
var variableDeclaration = CreateVariableDeclaration(declarator, preferExplicitType,
requireExplicitTypeForAll, vbInitializerType, declaredSymbolType, equalsValueClauseSyntax,
initSymbol, v);
csVars[k] = variableDeclaration;
}
else
{
csMethods.Add(initializerOrMethodDecl);
}
}
return(csVars.Values, csMethods);
}
private bool TryGenerateLiteral(ExpressionSyntax expression)
{
/*
* <ElementType name="Literal" content="eltOnly">
* - <group order="one">
* <element type="Null" />
* <element type="Number" />
* <element type="Boolean" />
* <element type="Char" />
* <element type="String" />
* <element type="Array" />
* <element type="Type" />
* </group>
* </ElementType>
*/
using (LiteralTag())
{
var constantValue = SemanticModel.GetConstantValue(expression);
if (!constantValue.HasValue)
{
return(false);
}
var type = SemanticModel.GetTypeInfo(expression).Type;
if (type == null)
{
return(false);
}
switch (expression.Kind())
{
case SyntaxKind.UnaryMinusExpression:
case SyntaxKind.NumericLiteralExpression:
GenerateNumber(constantValue.Value, type);
return(true);
case SyntaxKind.CharacterLiteralExpression:
GenerateChar((char)constantValue.Value);
return(true);
case SyntaxKind.StringLiteralExpression:
GenerateString((string)constantValue.Value);
return(true);
case SyntaxKind.TrueLiteralExpression:
case SyntaxKind.FalseLiteralExpression:
GenerateBoolean((bool)constantValue.Value);
return(true);
}
return(false);
}
}
protected bool HasNullConstantValue(SyntaxNode expression, SemanticModel model, CancellationToken cancellationToken)
{
if (expression == null)
{
return(false);
}
Optional <object> constantValue = model.GetConstantValue(expression, cancellationToken);
return(constantValue.HasValue && constantValue.Value == null);
}
internal static bool IsPositiveInfinity(SemanticModel semanticModel, SyntaxNode node)
{
var rr = semanticModel.GetConstantValue(node);
if (!rr.HasValue)
{
return(false);
}
return(rr.Value is double && double.IsPositiveInfinity((double)rr.Value) || rr.Value is float && float.IsPositiveInfinity((float)rr.Value));
}
public static bool NodeHasConstantValueIntZero(SyntaxNode node, SemanticModel model)
{
if (node == null || model == null)
{
return(false);
}
var value = model.GetConstantValue(node);
return(value.HasValue &&
value.Value is int &&
(int)value.Value == 0);
}
private static bool IsStringEmptyConst(ExpressionSyntax expression, SemanticModel semanticModel)
{
var constValue = semanticModel.GetConstantValue(expression);
if (!constValue.HasValue)
{
return(false);
}
return(constValue.Value is string stringConstValue && stringConstValue == string.Empty);
}
public static bool NodeHasConstantValueBoolFalse(SyntaxNode node, SemanticModel model)
{
if (node == null || model == null)
{
return(false);
}
var value = model.GetConstantValue(node);
return(value.HasValue &&
value.Value is bool &&
(bool)value.Value == false);
}
private static bool SupportsConstant(
TypeSyntax type,
VariableDeclaratorSyntax declarator,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
ExpressionSyntax value = declarator.Initializer?.Value;
return(value != null &&
semanticModel.GetTypeSymbol(type, cancellationToken)?.SupportsConstantValue() == true &&
semanticModel.GetConstantValue(value, cancellationToken).HasValue);
}
public static bool NodeHasConstantValue <T>(SyntaxNode node, SemanticModel model, T expectedValue) where T : struct
{
if (node == null || model == null)
{
return(false);
}
Optional <object> value = model.GetConstantValue(node);
return(value.HasValue &&
value.Value is T &&
((T)value.Value).Equals(expectedValue));
}
// Instantiate a binding attribute
public static Attribute MakeAttr(IJobHostMetadataProvider tooling, SemanticModel semantics, AttributeSyntax attrSyntax)
{
IMethodSymbol symAttributeCtor = (IMethodSymbol)semantics.GetSymbolInfo(attrSyntax).Symbol;
var syntaxParams = symAttributeCtor.Parameters;
INamedTypeSymbol attrType = symAttributeCtor.ContainingType;
if (!IsBindingAttribute(attrType))
{
return(null);
}
Type typeReflection = GetAttributeType(attrType);
JObject args = new JObject();
int idx = 0;
if (attrSyntax.ArgumentList != null)
{
foreach (var arg in attrSyntax.ArgumentList.Arguments)
{
var val = semantics.GetConstantValue(arg.Expression);
if (!val.HasValue)
{
return(null);
}
var v2 = val.Value;
string argName = null;
if (arg.NameColon != null)
{
argName = arg.NameColon.Name.ToString();
}
else if (arg.NameEquals != null)
{
argName = arg.NameEquals.Name.ToString();
}
else
{
argName = syntaxParams[idx].Name; // Positional
}
args[argName] = JToken.FromObject(v2);
idx++;
}
}
var attr = tooling.GetAttribute(typeReflection, args);
return(attr);
}
protected static ExpressionSyntax MakeTernaryOperand(ExpressionSyntax expression, SemanticModel semanticModel, ITypeSymbol type, TypeSyntax typeSyntax)
{
if (type?.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
{
var constValue = semanticModel.GetConstantValue(expression);
if (constValue.HasValue && constValue.Value == null)
{
return(SyntaxFactory.CastExpression(typeSyntax, expression));
}
}
return(expression);
}
static bool IsConstantExpression(SemanticModel context, ExpressionSyntax expr)
{
if (expr is LiteralExpressionSyntax)
{
return(true);
}
if (expr is DefaultExpressionSyntax)
{
return(true);
}
return(context.GetConstantValue(expr).HasValue);
}
private bool isValidPasswordComplexity(SemanticModel model, InitializerExpressionSyntax syntax)
{
if (syntax == null || syntax.Expressions.Count == 0)
{
return(false);
}
//Accouting for the inline assignment expression
int minLength = 0;
bool requireSpecialCharacter = false;
bool requireNumber = false;
bool requireUpperChar = false;
bool requireLowerChar = false;
foreach (AssignmentExpressionSyntax expression in syntax.Expressions)
{
//Get the property value
var value = model.GetConstantValue(expression.Right);
//If we have a value, set them to the local var
if (value.HasValue)
{
switch (expression.Left.ToString())
{
case "RequiredLength":
minLength = (int)value.Value;
break;
case "RequireNonLetterOrDigit":
requireSpecialCharacter = (bool)value.Value;
break;
case "RequireDigit":
requireNumber = (bool)value.Value;
break;
case "RequireLowercase":
requireLowerChar = (bool)value.Value;
break;
case "RequireUppercase":
requireUpperChar = (bool)value.Value;
break;
default:
break;
}
}
}
return(!isValidPasswordComplexity(minLength, requireSpecialCharacter, requireNumber, requireUpperChar, requireLowerChar));
}
/// <summary>
/// Detremines Password Lockout vulnerabilities
/// </summary>
/// <param name="syntaxNode"></param>
/// <param name="filePath"></param>
/// <param name="model"></param>
/// <param name="solution"></param>
/// <returns></returns>
public IEnumerable <VulnerabilityDetail> FindVulnerabilties(SyntaxNode syntaxNode, string filePath, SemanticModel model = null, Solution solution = null)
{
List <VulnerabilityDetail> vulnerabilities = new List <VulnerabilityDetail>();
var invocationExpressions = syntaxNode.DescendantNodes().OfType <InvocationExpressionSyntax>();
foreach (var item in invocationExpressions)
{
if (!(item.Expression is MemberAccessExpressionSyntax memberAccess) || !memberAccess.ToString().Contains("PasswordSignIn"))
{
continue;
}
ISymbol symbol = model.GetSymbol(memberAccess);
if (symbol == null)
{
continue;
}
if (symbol.ContainingNamespace.ToString() != KnownType.Microsoft_AspNet_Identity_Owin &&
symbol.ContainingNamespace.ToString() != KnownType.Microsoft_AspNetCore_Identity)
{
continue;
}
int argCount = symbol.Name == "CheckPasswordSignInAsync" ? 3 : 4;
string parameterName = symbol.ContainingNamespace.ToString() == KnownType.Microsoft_AspNet_Identity_Owin ? "shouldLockout" : "lockoutOnFailure";
if (item.ArgumentList == null || item.ArgumentList.Arguments.Count < argCount)
{
continue;
}
int i = -1;
foreach (var argument in item.ArgumentList.Arguments)
{
i++;
if (argument.NameColon == null && i != argCount - 1)
{
continue;
}
else if (argument.NameColon != null && argument.NameColon.Name.ToString() != parameterName)
{
continue;
}
var lockoutValue = model.GetConstantValue(argument.Expression);
if (lockoutValue.HasValue && lockoutValue.Value is bool value && !value)
{
vulnerabilities.Add(VulnerabilityDetail.Create(filePath, argument, Enums.ScannerType.PasswordLockout));
}
break;
}
}
return(vulnerabilities);
}
public override void VisitAssignmentExpression(AssignmentExpressionSyntax node)
{
base.VisitAssignmentExpression(node);
var rightSymbol = _semanticModel.GetSymbolInfo(node.Right).Symbol;
if (node.Left is ElementAccessExpressionSyntax)
{
// TODO
}
else
{
var leftSymbol = _semanticModel.GetSymbolInfo(node.Left).Symbol;
if (!IsUsedSymbol(leftSymbol) || !IsUsedSymbol(rightSymbol))
{
return;
}
var constValue = _semanticModel.GetConstantValue(node.Right);
if (rightSymbol != null && leftSymbol != null) // rightSymbol may be null if we have a boolean expression
{
AbstractNode rightSymbolNode;
if (rightSymbol is IMethodSymbol)
{
rightSymbolNode = new MethodReturnSymbol(rightSymbol as IMethodSymbol);
}
else
{
rightSymbolNode = new VariableSymbol(rightSymbol);
}
AddSubtypingRelation(new VariableSymbol(leftSymbol), rightSymbolNode);
}
else if (constValue.HasValue && leftSymbol != null)
{
AddSubtypingRelation(new VariableSymbol(leftSymbol), new LiteralSymbol(constValue.Value, node.GetLocation()));
}
}
}
private static bool InsideNameOfExpression(ExpressionSyntax expr, SemanticModel semanticModel)
{
var nameOfInvocationExpr = expr.FirstAncestorOrSelf<InvocationExpressionSyntax>(
invocationExpr =>
{
var expression = invocationExpr.Expression as IdentifierNameSyntax;
return (expression != null) && (expression.Identifier.Text == "nameof") &&
semanticModel.GetConstantValue(invocationExpr).HasValue &&
(semanticModel.GetTypeInfo(invocationExpr).Type.SpecialType == SpecialType.System_String);
});
return nameOfInvocationExpr != null;
}
private bool CanSimplifyToLengthEqualsZeroExpression(
ExpressionSyntax variableExpression,
LiteralExpressionSyntax numericLiteralExpression,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
var numericValue = semanticModel.GetConstantValue(numericLiteralExpression, cancellationToken);
if (numericValue.HasValue && numericValue.Value is int && (int)numericValue.Value == 0)
{
var symbol = semanticModel.GetSymbolInfo(variableExpression, cancellationToken).Symbol;
if (symbol != null && (symbol.Name == "Length" || symbol.Name == "LongLength"))
{
var containingType = symbol.ContainingType;
if (containingType != null &&
(containingType.SpecialType == SpecialType.System_Array ||
containingType.SpecialType == SpecialType.System_String))
{
return true;
}
}
var typeInfo = semanticModel.GetTypeInfo(variableExpression, cancellationToken);
if (typeInfo.Type != null)
{
switch (typeInfo.Type.SpecialType)
{
case SpecialType.System_Byte:
case SpecialType.System_UInt16:
case SpecialType.System_UInt32:
case SpecialType.System_UInt64:
return true;
}
}
}
return false;
}