public static IEnumerable <ExpressionSyntax> GetNonNewObjectReturnsForMethod(
BaseMethodDeclarationSyntax methodDeclaration,
SemanticModel semanticModel,
KnownSymbols knownSymbols, RecursiveState recursiveState1)
{
var methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration);
if (!methodSymbol.ReturnsByRef && IsCompleteValueType(methodSymbol.ReturnType))
{
yield break;
}
var returnExpressions =
methodDeclaration.Body != null
? methodDeclaration.Body
.DescendantNodes()
.OfType <ReturnStatementSyntax>()
.Select(x => x.Expression)
.ToArray()
: new[] { methodDeclaration.ExpressionBody.Expression };
foreach (var expression in returnExpressions)
{
if (!Utils.IsNewlyCreatedObject(semanticModel, expression, knownSymbols, RecursiveIsNewlyCreatedObjectState.Empty(), recursiveState1))
{
yield return(expression);
}
}
}
public static bool IsAccessOnNewlyCreatedObject(KnownSymbols knownSymbols,
SemanticModel semanticModel,
SyntaxNode node, RecursiveState recursiveState1)
{
bool IsOnNewlyCreatedObject(ExpressionSyntax exp)
{
if (exp is MemberAccessExpressionSyntax memberAccess1)
{
return(IsOnNewlyCreatedObject(memberAccess1.Expression));
}
if (exp is ElementAccessExpressionSyntax elementAccess1)
{
return(IsOnNewlyCreatedObject(elementAccess1.Expression));
}
return(Utils.IsNewlyCreatedObject(semanticModel, exp, knownSymbols, RecursiveIsNewlyCreatedObjectState.Empty(), recursiveState1));
}
if (node.Parent is MemberAccessExpressionSyntax memberAccess)
{
return(IsOnNewlyCreatedObject(memberAccess));
}
if (node is ElementAccessExpressionSyntax elementAccess)
{
return(IsOnNewlyCreatedObject(elementAccess));
}
return(false);
}
private void WsOnMessage(object sender, MessageEventArgs args)
{
try
{
var json = args.Data;
var data = JsonConvert.DeserializeObject <dynamic> (json);
foreach (var datum in data)
{
var s = (string)datum.s;
var symbol = s.Substring(0, 3);
if (!s.EndsWith("USDT"))
{
continue;
}
if (symbol == "BCC")
{
symbol = "BCH";
}
if (!KnownSymbols.Contains(symbol))
{
continue;
}
Update(datum, symbol);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void SetTextAndFontFamily(SymbolIconTag tag)
{
switch (tag.SymbolType)
{
case SymbolType.Glyph:
if (!string.IsNullOrWhiteSpace(tag.FontFamily))
{
this.FontFamily = new System.Windows.Media.FontFamily(tag.FontFamily);
}
else
{
this.FontFamily = new System.Windows.Media.FontFamily("Segoe MDL2 Assets");
}
this.Text = this.GetUnicode(tag.SymbolName) ?? string.Empty;
break;
case SymbolType.Symbol:
this.FontFamily = new System.Windows.Media.FontFamily("Segoe MDL2 Assets");
this.Text = KnownSymbols.ContainsKey(tag.SymbolName) ? KnownSymbols[tag.SymbolName] : string.Empty;
break;
case SymbolType.FontAwesome:
this.FontFamily = new System.Windows.Media.FontFamily($"file:///{System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)}/SymbolVisualizer/FontAwesome.otf#FontAwesome");
this.Text = KnownFontAwesomeIcons.ContainsKey(tag.SymbolName) ? KnownFontAwesomeIcons[tag.SymbolName] : string.Empty;
break;
default:
System.Diagnostics.Debugger.Break();
break;
}
}
public static bool ReturnsNewObject(PropertyDeclarationSyntax propertyDeclaration,
SemanticModel semanticModel,
KnownSymbols knownSymbols,
RecursiveState recursiveState1)
{
return(!GetNonNewObjectReturnsForPropertyGet(propertyDeclaration, semanticModel, knownSymbols, recursiveState1).Any());
}
private static async Task ConnectAndSubscribe(WebSocket ws, CancellationToken ct)
{
await Task.Run(() => ws.Connect( ), ct);
var productIds = string.Join(",", KnownSymbols.Select(x => $"\"{x}-USD\""));
await ws.SendStringAsync(
$"{{\"type\":\"subscribe\",\"product_ids\":[{productIds}],\"channels\":[\"ticker\"]}}");
}
public static IEnumerable <Impurity> GetImpurities(
SyntaxNode methodDeclaration,
SemanticModel semanticModel,
KnownSymbols knownSymbols,
RecursiveState recursiveState,
PurityType purityType = PurityType.Pure,
Maybe <PureLambdaConfig> pureLambdaConfig = default)
{
var impuritiesFinder = new ImpuritiesFinder(semanticModel, purityType, knownSymbols);
return(impuritiesFinder.GetImpurities(methodDeclaration, recursiveState, pureLambdaConfig));
}
private static bool MethodReturnsNewObject(
SemanticModel semanticModel,
KnownSymbols knownSymbols,
RecursiveState recursiveState,
IMethodSymbol invokedMethod)
{
if (invokedMethod.IsInCode() && !invokedMethod.IsAbstract)
{
var location = invokedMethod.Locations.First();
var locationSourceTree = location.SourceTree;
var node = locationSourceTree.GetRoot().FindNode(location.SourceSpan);
if (node is BaseMethodDeclarationSyntax methodNode)
{
if (ReturnsNewObject(
methodNode,
Utils.GetSemanticModel(semanticModel, methodNode.SyntaxTree),
knownSymbols, recursiveState))
{
return(true);
}
}
else if (node.Parent.Parent is PropertyDeclarationSyntax propertyDeclaration)
{
if (ReturnsNewObject(
propertyDeclaration,
Utils.GetSemanticModel(semanticModel, propertyDeclaration.SyntaxTree),
knownSymbols, recursiveState))
{
return(true);
}
}
}
else
{
if (GetAllAttributes(invokedMethod)
.Any(x => IsReturnsNewObjectAttribute(x.AttributeClass.Name)))
{
return(true);
}
if (knownSymbols.KnownReturnsNewObjectMethods.TryGetValue(
Utils.GetFullMetaDataName(invokedMethod.ContainingType), out var methods) &&
methods.AnyMatches(invokedMethod))
{
return(true);
}
}
return(false);
}
ChangeAcceptedPurityTypeBasedOnWhetherExpressionRepresentsANewObjectOrParameterBasedExpression(
PurityType currentAcceptedPurityType,
ExpressionSyntax node,
KnownSymbols knownSymbols,
SemanticModel semanticModel,
RecursiveState recursiveState)
{
if (Utils.IsNewlyCreatedObject(semanticModel, node, knownSymbols, RecursiveIsNewlyCreatedObjectState.Empty(), recursiveState))
{
return(PurityType.PureExceptLocally);
}
else if (ImpuritiesFinder.IsParameter(semanticModel, node))
{
return(PurityType.PureExceptReadLocally);
}
return(currentAcceptedPurityType);
}
public override async Task GetExchangeData(CancellationToken ct)
{
ExchangeData = new Dictionary <string, CryptoCoin> ( );
while (!ct.IsCancellationRequested)
{
var data = await TickerUrl.GetJsonAsync <List <CoinDeltaCoin> > (ct);
foreach (var datum in data)
{
var marketname = datum.MarketName.Split('-');
if (marketname[1] == "inr" && KnownSymbols.Contains(marketname[0].ToUpper( )))
{
Update(datum, marketname[0].ToUpper( ));
}
}
await Task.Delay(60000, ct);
}
}
public static bool AnyImpurePropertyInitializer(TypeDeclarationSyntax typeDeclaration,
SemanticModel semanticModel,
KnownSymbols knownSymbols,
RecursiveState recursiveState,
InstanceStaticCombination instanceStaticCombination)
{
var props = typeDeclaration
.Members
.OfType <PropertyDeclarationSyntax>()
.Where(instanceStaticCombination.Matches)
.ToArray();
foreach (var var in props.Select(x => x.Initializer).Where(i => i != null))
{
if (Utils.GetImpurities(var, semanticModel, knownSymbols, recursiveState).Any())
{
return(true);
}
}
return(false);
}
public static bool AnyImpureFieldInitializer(
TypeDeclarationSyntax typeDeclaration,
SemanticModel semanticModel,
KnownSymbols knownSymbols,
RecursiveState recursiveState,
InstanceStaticCombination instanceStaticCombination)
{
var fields =
typeDeclaration.Members
.OfType <FieldDeclarationSyntax>()
.Where(instanceStaticCombination.Matches)
.ToArray();
foreach (var var in fields.SelectMany(x => x.Declaration.Variables))
{
if (Utils.GetImpurities(var, semanticModel, knownSymbols, recursiveState).Any())
{
return(true);
}
}
return(false);
}
public static bool DoesMethodUseTAsObject_IncludingStaticConstructorsIfRelevant(
IMethodSymbol method,
SemanticModel semanticModel,
ITypeParameterSymbol typeParameter,
IMethodSymbol[] relevantObjectMethods,
KnownSymbols knownSymbols,
RecursiveStateForNotUsedAsObject recursiveStateForNotUsedAsObject)
{
IEnumerable <INamedTypeSymbol> GetAllContainingTypes()
{
var containingType = method.ContainingType;
while (containingType != null)
{
yield return(containingType);
containingType = containingType.ContainingType;
}
}
if (method.IsStatic || method.MethodKind == MethodKind.Constructor)
{
var containingTypes = GetAllContainingTypes().ToList();
var staticConstructors = containingTypes.SelectMany(x => x.StaticConstructors).ToList();
if (staticConstructors
.Any(c =>
DoesMethodUseTAsObject(c, semanticModel, typeParameter, relevantObjectMethods, knownSymbols, recursiveStateForNotUsedAsObject)))
{
return(true);
}
}
return(DoesMethodUseTAsObject(method, semanticModel, typeParameter, relevantObjectMethods, knownSymbols, recursiveStateForNotUsedAsObject));
}
public NullCheckScanner([NotNull] Compilation compilation)
{
Guard.NotNull(compilation, nameof(compilation));
knownSymbols = new KnownSymbols(compilation);
}
public static bool DoesMethodUseTAsObject(IMethodSymbol method, SemanticModel semanticModel,
ITypeParameterSymbol typeParameter, IMethodSymbol[] relevantObjectMethods, KnownSymbols knownSymbols,
RecursiveStateForNotUsedAsObject recursiveStateForNotUsedAsObject)
{
if (recursiveStateForNotUsedAsObject.ItemsInStack.Contains((method, typeParameter)))
{
return(false);
}
recursiveStateForNotUsedAsObject = recursiveStateForNotUsedAsObject.Add(method, typeParameter);
if (typeParameter.GetAttributes().Any(x => Utils.IsNotUsedAsObjectAttribute(x.AttributeClass.Name)))
{
return(false);
}
if (method.GetAttributes().Any(x =>
Utils.IsDoesNotUseClassTypeParameterAsObjectAttributeForTypeParameter(x, typeParameter.Name)))
{
return(false);
}
if (method.IsInCode())
{
var location = method.Locations.First();
var locationSourceTree = location.SourceTree;
var methodSyntax = locationSourceTree.GetRoot().FindNode(location.SourceSpan);
return(GetNodesWhereTIsUsedAsObject(methodSyntax, semanticModel, relevantObjectMethods, typeParameter,
knownSymbols, recursiveStateForNotUsedAsObject).Any());
}
if (typeParameter.DeclaringMethod != null)
{
if (knownSymbols.KnownNotUsedAsObjectMethodTypeParameters.TryGetValue(
Utils.GetFullMetaDataName(typeParameter.DeclaringMethod.ContainingType),
out var methods) &&
methods.Keys.FirstOrNoValue(x => x.Matches(typeParameter.DeclaringMethod))
.HasValueAnd(x => methods[x].Contains(typeParameter.Name)))
{
return(false);
}
}
else
{
if (knownSymbols.KnownNotUsedAsObjectClassTypeParameters.TryGetValue(
Utils.GetFullMetaDataName(typeParameter.DeclaringType),
out var methods) &&
methods.Contains(typeParameter.Name))
{
return(false);
}
}
return(true);
}
public static IEnumerable <SyntaxNode> GetNodesWhereTIsUsedAsObject(SyntaxNode scope,
SemanticModel semanticModel,
IMethodSymbol[] relevantObjectMethods,
ITypeParameterSymbol typeParameterSymbol,
KnownSymbols knownSymbols,
RecursiveStateForNotUsedAsObject recursiveStateForNotUsedAsObject)
{
var objectType = semanticModel.Compilation.ObjectType;
var invocationOperations = scope.DescendantNodes()
.OfType <InvocationExpressionSyntax>()
.Select(x => semanticModel.GetOperation(x))
.OfType <IInvocationOperation>()
.Where(x => x.TargetMethod.ContainingType.TypeKind != TypeKind.Delegate)
.ToList();
var invocationsOfObjectMethodsOnExpressionsOfTypeT =
invocationOperations
.Where(x => x.Instance?.Type.Equals(typeParameterSymbol) ?? false)
.Where(x => relevantObjectMethods.Contains(x.TargetMethod))
.ToList();
foreach (var inv in invocationsOfObjectMethodsOnExpressionsOfTypeT)
{
yield return(inv.Syntax);
}
var conversions =
Utils.GetConversions(scope, semanticModel);
var conversionsFromTToObject =
conversions.Where(x => [email protected](typeParameterSymbol) &&
x.to.Equals(objectType))
.Select(x => x.node)
.ToList();
foreach (var conv in conversionsFromTToObject)
{
yield return(conv);
}
var constructionOperations =
scope.DescendantNodes()
.OfType <ObjectCreationExpressionSyntax>()
.Select(x => semanticModel.GetOperation(x))
.OfType <IObjectCreationOperation>()
.Where(x => x.Constructor.ContainingType.TypeKind != TypeKind.Delegate)
.ToList();
var invokedMethodsAndConstructorsWithRelevantTypeParameters =
invocationOperations
.Select(x => (Method: x.TargetMethod, x.Syntax))
.Concat(constructionOperations.Select(x => (Method: x.Constructor, x.Syntax)))
.Select(x => (
node: x.Syntax,
method: x.Method,
typeParamsAndArgs:
GetTypeParametersAndMatchingArguments(x.Method)
.Where(p =>
p.argument.Equals(typeParameterSymbol)).ToList()))
.ToList();
foreach (var invokedMethodOrConstructor in invokedMethodsAndConstructorsWithRelevantTypeParameters)
{
foreach (var tp in invokedMethodOrConstructor.typeParamsAndArgs)
{
if (DoesMethodUseTAsObject_IncludingStaticConstructorsIfRelevant(
invokedMethodOrConstructor.method,
semanticModel,
tp.typeParameter,
relevantObjectMethods,
knownSymbols,
recursiveStateForNotUsedAsObject))
{
yield return(invokedMethodOrConstructor.node);
break;
}
}
}
}
public static IEnumerable <ExpressionSyntax> GetNonNewObjectReturnsForPropertyGet(
PropertyDeclarationSyntax propertyDeclaration,
SemanticModel semanticModel,
KnownSymbols knownSymbols,
RecursiveState recursiveState1)
{
var propertySymbol = semanticModel.GetDeclaredSymbol(propertyDeclaration);
if (propertySymbol.GetMethod == null)
{
yield break;
}
if (!propertySymbol.ReturnsByRef && IsCompleteValueType(propertySymbol.Type))
{
yield break;
}
List <ExpressionSyntax> returnExpressions;
if (propertyDeclaration.AccessorList != null)
{
var getAccessor =
propertyDeclaration.AccessorList.Accessors.FirstOrNoValue(x =>
x.Keyword.Kind() == SyntaxKind.GetKeyword);
if (getAccessor.HasNoValue)
{
yield break;
}
var getAccessorValue = getAccessor.GetValue();
returnExpressions =
getAccessorValue.ExpressionBody != null
? new List <ExpressionSyntax>()
{
getAccessorValue.ExpressionBody.Expression
}
: getAccessor.GetValue()
.DescendantNodes()
.OfType <ReturnStatementSyntax>()
.Select(x => x.Expression)
.ToList();
}
else if (propertyDeclaration.ExpressionBody != null)
{
returnExpressions = new List <ExpressionSyntax>()
{
propertyDeclaration.ExpressionBody.Expression
};
}
else
{
yield break;
}
foreach (var expression in returnExpressions)
{
if (!Utils.IsNewlyCreatedObject(semanticModel, expression, knownSymbols, RecursiveIsNewlyCreatedObjectState.Empty(), recursiveState1))
{
yield return(expression);
}
}
}
public static bool ReturnsNewObject(BaseMethodDeclarationSyntax methodDeclaration,
SemanticModel semanticModel,
KnownSymbols knownSymbols, RecursiveState recursiveState1)
{
return(!GetNonNewObjectReturnsForMethod(methodDeclaration, semanticModel, knownSymbols, recursiveState1).Any());
}
public static List <ExpressionSyntax> GetValuesPossiblyInjectedInto(SemanticModel semanticModel,
ILocalSymbol variable,
SyntaxNode containingBlockNode, KnownSymbols knownSymbols, RecursiveState recursiveState)
{
var usages = containingBlockNode
.DescendantNodes()
.OfType <IdentifierNameSyntax>()
.Where(x => x.Identifier.Text == variable.Name)
.Where(x => semanticModel.GetSymbolInfo(x).Symbol?.Equals(variable) ?? false)
.Select(x => x.Parent)
.ToList();
List <ExpressionSyntax> result = new List <ExpressionSyntax>();
void HandleMemberAccess(MemberAccessExpressionSyntax usage)
{
if (usage.Parent is AssignmentExpressionSyntax assignment)
{
result.Add(assignment.Right);
}
else if (usage.Parent is InvocationExpressionSyntax invocation)
{
if (semanticModel.GetSymbolInfo(invocation.Expression).Symbol is IMethodSymbol invokedMethod)
{
var purityType = ImpuritiesFinder.GetMethodPurityType(semanticModel, knownSymbols,
invokedMethod, recursiveState);
if (purityType.HasValueAnd(x => x.Equals(PurityType.PureExceptLocally)))
{
result.AddRange(invocation.ArgumentList.Arguments.Select(x => x.Expression));
}
}
}
else if (usage.Parent is MemberAccessExpressionSyntax memberAccess)
{
HandleMemberAccess(memberAccess);
}
}
foreach (var usage in usages)
{
if (usage is MemberAccessExpressionSyntax memberAccess)
{
HandleMemberAccess(memberAccess);
}
else if (usage is ElementAccessExpressionSyntax elementAccess)
{
if (elementAccess.Parent is AssignmentExpressionSyntax assignment)
{
result.Add(assignment.Right);
}
}
}
return(result);
}
public static bool IsNewlyCreatedObject(SemanticModel semanticModel,
SyntaxNode expression,
KnownSymbols knownSymbols,
RecursiveIsNewlyCreatedObjectState recursiveState, RecursiveState recursiveState1)
{
if (expression is LiteralExpressionSyntax)
{
return(true);
}
if (expression is TupleExpressionSyntax tuple)
{
return(tuple.Arguments
.Select(x => x.Expression)
.All(x => IsNewlyCreatedObject(semanticModel, x, knownSymbols, recursiveState, recursiveState1)));
}
if (expression is ObjectCreationExpressionSyntax objectCreationExpression)
{
if (objectCreationExpression
.ArgumentList != null)
{
if (objectCreationExpression
.ArgumentList
.Arguments.Any(arg =>
!IsNewlyCreatedObject(semanticModel, arg.Expression, knownSymbols, recursiveState, recursiveState1)))
{
return(false);
}
}
if (objectCreationExpression.Initializer != null)
{
if (objectCreationExpression
.Initializer
.Expressions
.OfType <AssignmentExpressionSyntax>()
.Any(x =>
!IsNewlyCreatedObject(semanticModel, x.Right, knownSymbols, recursiveState, recursiveState1)))
{
return(false);
}
}
return(true);
}
if (expression is ArrayCreationExpressionSyntax arrayCreationExpression)
{
if (arrayCreationExpression.Initializer != null)
{
if (arrayCreationExpression
.Initializer
.Expressions
.Any(x =>
!IsNewlyCreatedObject(semanticModel, x, knownSymbols, recursiveState, recursiveState1)))
{
return(false);
}
}
return(true);
}
if (expression is ImplicitArrayCreationExpressionSyntax arrayCreationExpression1)
{
if (arrayCreationExpression1.Initializer != null)
{
if (arrayCreationExpression1
.Initializer
.Expressions
.Any(x =>
!IsNewlyCreatedObject(semanticModel, x, knownSymbols, recursiveState, recursiveState1)))
{
return(false);
}
}
return(true);
}
if (expression is InitializerExpressionSyntax initSyntax &&
initSyntax.Kind() == SyntaxKind.ArrayInitializerExpression)
{
if (initSyntax
.Expressions
.Any(x =>
!IsNewlyCreatedObject(semanticModel, x, knownSymbols, recursiveState, recursiveState1)))
{
return(false);
}
return(true);
}
if (expression is InvocationExpressionSyntax invocationExpression)
{
if (semanticModel.GetSymbolInfo(invocationExpression.Expression).Symbol is IMethodSymbol invokedMethod)
{
if (MethodReturnsNewObject(semanticModel, knownSymbols, recursiveState1, invokedMethod))
{
return(true);
}
}
}
if (expression is MemberAccessExpressionSyntax memberAccessExpression)
{
if (semanticModel.GetSymbolInfo(memberAccessExpression.Name).Symbol is IPropertySymbol propertySymbol && !GetUsage(memberAccessExpression.Name).IsWrite())
{
if (MethodReturnsNewObject(semanticModel, knownSymbols, recursiveState1, propertySymbol.GetMethod))
{
return(true);
}
}
}
if (expression is IdentifierNameSyntax identifier)
{
var identifierSymbol = semanticModel.GetSymbolInfo(identifier).Symbol;
if (identifierSymbol is ILocalSymbol local)
{
if (!local.IsRef && IsCompleteValueType(local.Type))
{
return(true);
}
if (recursiveState.VariablesUnderTest.Contains(local))
{
return(true);
}
var methodBody =
GetBodyOfMethodThatContainsExpression(expression);
if (methodBody.HasNoValue)
{
return(false);
}
var valuesInjectedIntoObject =
GetValuesPossiblyInjectedInto(semanticModel, local, methodBody.GetValue(), knownSymbols, recursiveState1);
if (!valuesInjectedIntoObject.All(x =>
{
var typeSymbol = semanticModel.GetTypeInfo(x).Type;
if (typeSymbol != null && IsImmutablePureData(typeSymbol))
{
return(true);
}
return(IsNewlyCreatedObject(semanticModel, x, knownSymbols, recursiveState.Add(local),
recursiveState1));
}))
{
return(false);
}
return(FindValuesAssignedToVariable(semanticModel, local, methodBody.GetValue()).All(x =>
IsNewlyCreatedObject(semanticModel, x, knownSymbols, recursiveState.Add(local), recursiveState1)));
}
}
if (semanticModel.GetTypeInfo(expression).Type is ITypeSymbol type)
{
if (IsCompleteValueType(type))
{
return(true);
}
}
return(false);
}
