public void IsAsyncLibraryConstruct(IMethodSymbol symbol)
{
if (symbol.ContainingNamespace.ToString().Equals("System.Threading.Tasks") ||
symbol.ContainingNamespace.ToString().Equals("System.Threading") ||
(symbol.ContainingNamespace.ToString().Equals("System.Linq") && (symbol.ContainingType.ToString().Contains("ParallelQuery") || symbol.ContainingType.ToString().Contains("ParallelEnumerable"))) ||
symbol.ContainingNamespace.ToString().Equals("System.Collections.Concurrent"))
{
if (ConsultingAnalysisResult.libraryUsage.ContainsKey(symbol.ToString()))
ConsultingAnalysisResult.libraryUsage[symbol.ToString()]++;
else
ConsultingAnalysisResult.libraryUsage[symbol.ToString()] = 1;
}
}
private static void Analyze(SyntaxNodeAnalysisContext context)
{
InvocationExpressionSyntax invocationExpression = (InvocationExpressionSyntax)context.Node;
MemberAccessExpressionSyntax memberAccessExpression = invocationExpression.Expression as MemberAccessExpressionSyntax;
if (memberAccessExpression == null)
{
return;
}
string memberName = memberAccessExpression.Expression.ToString();
string name = memberAccessExpression.Name.ToString();
Location location;
if (memberName == @"Thread" && name == @"Sleep")
{
ClassDeclarationSyntax classDeclaration = (ClassDeclarationSyntax)context.Node.Parent.Parent.Parent.Parent;
SyntaxList <AttributeListSyntax> classAttributeList = classDeclaration.AttributeLists;
if (Helper.HasAttribute(classAttributeList, context, MsTestFrameworkDefinitions.TestClassAttribute, out location))
{
IMethodSymbol memberSymbol = context.SemanticModel.GetSymbolInfo(memberAccessExpression).Symbol as IMethodSymbol;
if ((memberSymbol != null) && memberSymbol.ToString().StartsWith("System.Threading.Thread"))
{
Diagnostic diagnostic = Diagnostic.Create(Rule, invocationExpression.GetLocation());
context.ReportDiagnostic(diagnostic);
}
}
}
}
public void Analyze(ClassDeclarationSyntax classDeclarationSyntax, ClassModel classModel)
{
List <MethodDeclarationSyntax> methodDeclarationSyntaxes = classDeclarationSyntax
.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.ToList();
foreach (MethodDeclarationSyntax methodDeclarationSyntax in methodDeclarationSyntaxes)
{
MethodModel methodModel = new MethodModel();
methodModel.Name = methodDeclarationSyntax.Identifier.Text;
IMethodSymbol methodSymbol = SemanticModel.GetDeclaredSymbol(methodDeclarationSyntax) as IMethodSymbol;
if (methodSymbol != null && !methodSymbol.IsAbstract)
{
ControlFlowGraph controlFlowGraph = ControlFlowGraph
.Create(methodDeclarationSyntax, SemanticModel, CancellationToken.None);
int numberOfBlocks = controlFlowGraph.Blocks.Length;
int numberOfEdges = 0;
foreach (BasicBlock basicBlock in controlFlowGraph.Blocks)
{
if (basicBlock.ConditionalSuccessor != null)
{
numberOfEdges++;
}
if (basicBlock.FallThroughSuccessor != null)
{
numberOfEdges++;
}
}
methodModel.CyclomaticComplexity = numberOfEdges - numberOfBlocks + 2;
}
methodModel.Fqn = methodSymbol.ToString();
methodModel.Static = methodSymbol.IsStatic;
methodModel.Abstract = methodSymbol.IsAbstract;
methodModel.Sealed = methodSymbol.IsSealed;
methodModel.Async = methodSymbol.IsAsync;
methodModel.Override = methodSymbol.IsOverride;
methodModel.Virtual = methodSymbol.IsVirtual;
methodModel.Extern = methodSymbol.IsExtern;
methodModel.Accessibility = methodSymbol.DeclaredAccessibility.ToString();
methodModel.ReturnType = methodSymbol.ReturnType.ToString();
methodModel.FirstLineNumber =
methodDeclarationSyntax.GetLocation().GetLineSpan().StartLinePosition.Line + 1;
methodModel.LastLineNumber =
methodDeclarationSyntax.GetLocation().GetLineSpan().EndLinePosition.Line + 1;
_invocationAnalyzer.Analyze(methodDeclarationSyntax, methodModel);
_parameterAnalyzer.Analyze(methodDeclarationSyntax, methodModel);
classModel.Methods.Add(methodModel);
}
}
public Task(IMethodSymbol symbol, bool step)
{
CheckSignature(symbol);
Signature = symbol.ToString();
this.symbol = symbol;
this.step = step;
}
private void ProcessInvocations(IEnumerable <InvocationExpressionSyntax> invocationExpressionSyntaxes,
MethodModel methodModel)
{
foreach (InvocationExpressionSyntax invocationExpressionSyntax in invocationExpressionSyntaxes)
{
IMethodSymbol methodSymbol = null;
MemberAccessExpressionSyntax memberAccessExpressionSyntax =
invocationExpressionSyntax.Expression as MemberAccessExpressionSyntax;
IdentifierNameSyntax identifierNameSyntax =
invocationExpressionSyntax.Expression as IdentifierNameSyntax;
if (memberAccessExpressionSyntax != null)
{
methodSymbol = SemanticModel.GetSymbolInfo(memberAccessExpressionSyntax).Symbol as IMethodSymbol;
}
else if (identifierNameSyntax != null)
{
methodSymbol = SemanticModel.GetSymbolInfo(identifierNameSyntax).Symbol as IMethodSymbol;
}
InvokesModel invokesModel = new InvokesModel
{
LineNumber = invocationExpressionSyntax.GetLocation().GetLineSpan().StartLinePosition.Line + 1,
MethodId = methodSymbol?.ToString()
};
methodModel.Invocations.Add(invokesModel);
}
}
private void Analyze(SyntaxNodeAnalysisContext context)
{
Diagnostic diagnostic = null;
InvocationExpressionSyntax invocationExpression = (InvocationExpressionSyntax)context.Node;
MemberAccessExpressionSyntax memberAccessExpression = invocationExpression?.Expression as MemberAccessExpressionSyntax;
if (memberAccessExpression == null)
{
return;
}
if (memberAccessExpression.Expression is IdentifierNameSyntax identifier && identifier.Identifier.Text.EndsWith("Assert"))
{
diagnostic = Analyze(context, invocationExpression, memberAccessExpression);
}
if (diagnostic != null)
{
IMethodSymbol memberSymbol = context.SemanticModel.GetSymbolInfo(memberAccessExpression).Symbol as IMethodSymbol;
if ((memberSymbol == null) || !memberSymbol.ToString().StartsWith("Microsoft.VisualStudio.TestTools.UnitTesting.Assert"))
{
return;
}
context.ReportDiagnostic(diagnostic);
}
}
private static void Analyze(SyntaxNodeAnalysisContext context)
{
var mds = context.Node as InvocationExpressionSyntax;
if (mds == null)
{
return;
}
MemberAccessExpressionSyntax maes = mds.Expression as MemberAccessExpressionSyntax;
if (maes == null)
{
return;
}
string memberName = maes.Name.ToString();
if ((memberName != @"AreEqual") && (memberName != @"AreNotEqual"))
{
return;
}
IMethodSymbol memberSymbol = context.SemanticModel.GetSymbolInfo(maes).Symbol as IMethodSymbol;
if ((memberSymbol == null) || !memberSymbol.ToString().StartsWith("Microsoft.VisualStudio.TestTools.UnitTesting.Assert"))
{
return;
}
// If it resolved to Are[Not]Equal<T>, then we know the types are the same.
if (memberSymbol.IsGenericMethod)
{
return;
}
ArgumentListSyntax argumentList = mds.ArgumentList as ArgumentListSyntax;
TypeInfo ti1 = context.SemanticModel.GetTypeInfo(argumentList.Arguments[0].Expression);
TypeInfo ti2 = context.SemanticModel.GetTypeInfo(argumentList.Arguments[1].Expression);
// Our <actual> is of type object. If it matches the type of <expected>, then AreEqual will pass, so we wouldn't want to fail here.
// However, if the types differ, it will be a runtime Assert fail, so the early notice is advantageous. The code is also clearer.
// Moreover, if it were "AreNotEqual", that is particularly insidious, because the Assert would pass due to the type difference
// rather than the value difference. Let's play it safe, and require the author to be clear.
//if (ti2.Type.ToString() == @"object")
//{
// return;
//}
if (!context.SemanticModel.Compilation.ClassifyConversion(ti2.Type, ti1.Type).IsImplicit)
{
Diagnostic diagnostic = Diagnostic.Create(Rule, mds.GetLocation(), ti1.Type.ToString(), ti2.Type.ToString());
context.ReportDiagnostic(diagnostic);
}
}
protected override Diagnostic Analyze(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocationExpressionSyntax, MemberAccessExpressionSyntax memberAccessExpression)
{
string memberName = memberAccessExpression.Name.ToString();
if ((memberName != @"AreEqual") && (memberName != @"AreNotEqual"))
{
return(null);
}
IMethodSymbol memberSymbol = context.SemanticModel.GetSymbolInfo(memberAccessExpression).Symbol as IMethodSymbol;
if ((memberSymbol == null) || !memberSymbol.ToString().StartsWith("Microsoft.VisualStudio.TestTools.UnitTesting.Assert"))
{
return(null);
}
// Assert.AreEqual is incorrectly used if the literal is the second argument (including null) or if the first argument is null
bool isUsedIncorrectly = false;
ArgumentListSyntax argumentList = invocationExpressionSyntax.ArgumentList as ArgumentListSyntax;
LiteralExpressionSyntax arg0Literal = argumentList.Arguments[0].Expression as LiteralExpressionSyntax;
LiteralExpressionSyntax arg1Literal = argumentList.Arguments[1].Expression as LiteralExpressionSyntax;
if ((arg1Literal != null) || Helper.IsConstantExpression(argumentList.Arguments[1].Expression, context.SemanticModel))
{
if ((arg0Literal == null) && !Helper.IsConstantExpression(argumentList.Arguments[0].Expression, context.SemanticModel))
{
isUsedIncorrectly = true;
}
else if (arg1Literal != null)
{
Optional <object> literalValue = context.SemanticModel.GetConstantValue(arg1Literal);
if (literalValue.Value == null)
{
isUsedIncorrectly = true;
}
}
}
else if (arg0Literal != null)
{
Optional <object> literalValue = context.SemanticModel.GetConstantValue(arg0Literal);
if (literalValue.Value == null)
{
isUsedIncorrectly = true;
}
}
if (isUsedIncorrectly)
{
Diagnostic diagnostic = Diagnostic.Create(Rule, invocationExpressionSyntax.GetLocation());
return(diagnostic);
}
return(null);
}
static void CheckSignature(IMethodSymbol symbol)
{
bool hasDuplicateParameters = symbol.Parameters
.GroupBy(p => p.Name, StringComparer.OrdinalIgnoreCase)
.Any(p => p.Count() > 1);
if (!symbol.ReturnsVoid ||
symbol.IsGenericMethod ||
symbol.Parameters.Any(p => p.RefKind != RefKind.None || !TypeConverter.IsSupported(p.Type)) ||
hasDuplicateParameters)
{
throw new TaskSignatureViolationException(symbol.ToString());
}
}
private MethodDetails GetMethodDetails(IMethodSymbol methodSymbol)
{
var fullMethodName = methodSymbol.ToString().Replace("()", "");
if (methodSymbol.IsGenericMethod)
{
fullMethodName = fullMethodName.Split('<')[0];
fullMethodName = $"{fullMethodName}``{methodSymbol.Arity}";
}
return(new MethodDetails
{
FullName = fullMethodName
});
}
public void Analyze(SyntaxNodeAnalysisContext context)
{
IEnumerable <MethodDeclarationSyntax> ancestorMethods = context.Node.Ancestors().OfType <MethodDeclarationSyntax>();
if (ancestorMethods.Count() > 0)
{
MethodDeclarationSyntax parentMethod = ancestorMethods.First();
if (parentMethod.Identifier.Text == @"Dispose")
{
IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(parentMethod);
if ((methodSymbol != null) && methodSymbol.ToString().Contains(".Dispose("))
{
context.ReportDiagnostic(Diagnostic.Create(Rule, context.Node.GetLocation()));
}
}
}
}
public static bool HasAttribute(AttributeListSyntax attributes, SyntaxNodeAnalysisContext context, string name, string fullName, out Location location)
{
location = null;
foreach (AttributeSyntax attribute in attributes.Attributes)
{
if (attribute.Name.ToString().Contains(name))
{
IMethodSymbol memberSymbol = context.SemanticModel.GetSymbolInfo(attribute).Symbol as IMethodSymbol;
if (memberSymbol != null && memberSymbol.ToString().StartsWith(fullName))
{
location = attribute.GetLocation();
return(true);
}
}
}
return(false);
}
public static bool TryGetAttribute(AttributeListSyntax attributes, SyntaxNodeAnalysisContext context, AttributeDefinition attributeDefinition, out AttributeSyntax attribute)
{
foreach (AttributeSyntax attr in attributes.Attributes)
{
if (attr.Name.ToString().Contains(attributeDefinition.Name))
{
IMethodSymbol memberSymbol = context.SemanticModel.GetSymbolInfo(attr).Symbol as IMethodSymbol;
if (memberSymbol != null && memberSymbol.ToString().StartsWith(attributeDefinition.FullName))
{
attribute = attr;
return(true);
}
}
}
attribute = default;
return(false);
}
protected override IEnumerable <Diagnostic> Analyze(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocationExpressionSyntax, MemberAccessExpressionSyntax memberAccessExpression)
{
string memberName = memberAccessExpression.Name switch
{
GenericNameSyntax generic => generic.Identifier.ToString(),
SimpleNameSyntax name => name.ToString()
};
if ((memberName != @"AreEqual") && (memberName != @"AreNotEqual"))
{
return(null);
}
IMethodSymbol memberSymbol = context.SemanticModel.GetSymbolInfo(memberAccessExpression).Symbol as IMethodSymbol;
if ((memberSymbol == null) || !memberSymbol.ToString().StartsWith("Microsoft.VisualStudio.TestTools.UnitTesting.Assert"))
{
return(null);
}
// Assert.AreEqual is incorrectly used if the literal is the second argument (including null) or if the first argument is null
ArgumentListSyntax argumentList = invocationExpressionSyntax.ArgumentList;
bool arg0Literal = IsLiteral(argumentList.Arguments[0].Expression, context.SemanticModel);
bool arg1Literal = IsLiteral(argumentList.Arguments[1].Expression, context.SemanticModel);
if (!arg0Literal && !arg1Literal)
{
return(null);
}
if (arg0Literal)
{
return(null);
}
if (arg1Literal)
{
Diagnostic diagnostic = Diagnostic.Create(Rule, invocationExpressionSyntax.GetLocation());
return(new[] { diagnostic });
}
return(null);
}
private static bool IsSelectingADifferentMethod(IEnumerable<SyntaxNode> childNodes, SimpleNameSyntax methodName, SyntaxTree tree, IMethodSymbol methodSymbol, ExpressionSyntax invocationExpression, Compilation compilation)
{
var parameterExpressions = GetParameterExpressions(childNodes);
var firstArgument = parameterExpressions.FirstOrDefault();
var argumentList = CreateArgumentListSyntaxFrom(parameterExpressions.Skip(1));
var newInvocationStatement = CreateInvocationExpression(firstArgument, methodName, argumentList)
.WithAdditionalAnnotations(introduceExtensionMethodAnnotation);
var extensionMethodNamespaceUsingDirective = SyntaxFactory.UsingDirective(methodSymbol.ContainingNamespace.ToNameSyntax());
var speculativeRootWithExtensionMethod = tree.GetCompilationUnitRoot()
.ReplaceNode(invocationExpression, newInvocationStatement)
.AddUsings(extensionMethodNamespaceUsingDirective);
var speculativeTree = speculativeRootWithExtensionMethod.SyntaxTree;
var speculativeTreeOptions = (CSharpParseOptions)speculativeTree.Options;
var speculativeTreeWithCorrectLanguageVersion = speculativeTree.WithRootAndOptions(speculativeRootWithExtensionMethod, speculativeTreeOptions.WithLanguageVersion(((CSharpParseOptions)tree.Options).LanguageVersion));
var speculativeModel = compilation.ReplaceSyntaxTree(tree, speculativeTreeWithCorrectLanguageVersion)
.GetSemanticModel(speculativeTreeWithCorrectLanguageVersion);
var speculativeInvocationStatement = speculativeTreeWithCorrectLanguageVersion.GetCompilationUnitRoot().GetAnnotatedNodes(introduceExtensionMethodAnnotation).Single() as InvocationExpressionSyntax;
var speculativeExtensionMethodSymbol = speculativeModel.GetSymbolInfo(speculativeInvocationStatement.Expression).Symbol as IMethodSymbol;
var speculativeNonExtensionFormOfTheMethodSymbol = speculativeExtensionMethodSymbol?.GetConstructedReducedFrom();
return speculativeNonExtensionFormOfTheMethodSymbol == null || speculativeNonExtensionFormOfTheMethodSymbol.ToString() != methodSymbol.ToString();//can't compare equality, as speculative symbol might be different
}
public static bool IsAttribute(AttributeSyntax attribute, SyntaxNodeAnalysisContext context, string name, string fullName, out Location location, out AttributeArgumentSyntax argument)
{
location = null;
argument = default(AttributeArgumentSyntax);
if (attribute.Name.ToString().Contains(name))
{
IMethodSymbol memberSymbol = context.SemanticModel.GetSymbolInfo(attribute).Symbol as IMethodSymbol;
if (memberSymbol != null && memberSymbol.ToString().StartsWith(fullName))
{
location = attribute.GetLocation();
if (attribute.ArgumentList != null && attribute.ArgumentList.Arguments.Count > 0)
{
argument = attribute.ArgumentList.Arguments.First();
}
return(true);
}
}
return(false);
}
private List <ConstructorModel> FindContructors(SyntaxNode syntaxNode)
{
List <ConstructorDeclarationSyntax> constructorDeclarationSyntaxes = syntaxNode
.DescendantNodes()
.OfType <ConstructorDeclarationSyntax>()
.ToList();
List <ConstructorModel> result = new List <ConstructorModel>();
foreach (ConstructorDeclarationSyntax constructorDeclarationSyntax in constructorDeclarationSyntaxes)
{
ConstructorModel constructorModel = new ConstructorModel();
constructorModel.Name = constructorDeclarationSyntax.Identifier.Text;
IMethodSymbol methodSymbol =
SemanticModel.GetDeclaredSymbol(constructorDeclarationSyntax) as IMethodSymbol;
constructorModel.Fqn = methodSymbol.ToString();
constructorModel.Static = methodSymbol.IsStatic;
constructorModel.Abstract = methodSymbol.IsAbstract;
constructorModel.Sealed = methodSymbol.IsSealed;
constructorModel.Async = methodSymbol.IsAsync;
constructorModel.Override = methodSymbol.IsOverride;
constructorModel.Virtual = methodSymbol.IsVirtual;
constructorModel.Accessibility = methodSymbol.DeclaredAccessibility.ToString();
constructorModel.FirstLineNumber =
constructorDeclarationSyntax.GetLocation().GetLineSpan().StartLinePosition.Line + 1;
constructorModel.LastLineNumber =
constructorDeclarationSyntax.GetLocation().GetLineSpan().EndLinePosition.Line + 1;
_invocationAnalyzer.Analyze(constructorDeclarationSyntax, constructorModel);
_parameterAnalyzer.Analyze(constructorDeclarationSyntax, constructorModel);
result.Add(constructorModel);
}
return(result);
}
public void IsAsyncLibraryConstruct(IMethodSymbol symbol)
{
if (symbol.ContainingNamespace.ToString().Equals("System.Threading.Tasks") ||
symbol.ContainingNamespace.ToString().Equals("System.Threading") ||
(symbol.ContainingNamespace.ToString().Equals("System.Linq") && (symbol.ContainingType.ToString().Contains("ParallelQuery") || symbol.ContainingType.ToString().Contains("ParallelEnumerable"))) ||
symbol.ContainingNamespace.ToString().Equals("System.Collections.Concurrent"))
{
var libraryUsage = Result.LibraryUsage;
int temp;
string key = symbol.ToString();
libraryUsage.TryGetValue(key, out temp);
libraryUsage[key] = ++temp;
}
}
public void Add(IMethodSymbol ms)
{
if (IsLibrary)
return;
FlatArrayBuilder fab = new FlatArrayBuilder();
fab.Add(FlatValue.Int32(ms.IsStatic ? (int)ClassMemberType.StaticMethod : (int)ClassMemberType.Method));
fab.Add(FlatValue.String(ms.GetFullyQualifiedName()));
Function f;
if (!Chunk.Functions.TryGetValue(ms, out f))
{
throw new LS2ILMethodException("Method not found " + ms.ToString());
}
fab.Add(FlatValue.Int32(f.NumFunction));
// input declarations
fab.Add(GenerateInputDeclarations(ms).GetFlatValue());
Members.Add(fab.GetFlatValue());
}
private void DetectBlockingOperations(InvocationExpressionSyntax methodCall, IMethodSymbol methodCallSymbol)
{
var methodDeclaration = methodCall.FirstAncestorOrSelf<MethodDeclarationSyntax>();
var replacement = ((IMethodSymbol)methodCallSymbol.OriginalDefinition).DetectSynchronousUsages(SemanticModel);
if (methodDeclaration != null)
{
if (replacement != "None")
{
Logs.TempLog6.Info(@"{0}{1}{2}{3}**********************************************",
Document.FilePath,
System.Environment.NewLine + System.Environment.NewLine + "BLOCKING METHODCALL: " + methodCallSymbol.ToString(),
System.Environment.NewLine + System.Environment.NewLine + "REPLACE IT WITH: " + replacement,
methodDeclaration.ToLog());
}
}
}
static bool IsStringFormatInvocation(IMethodSymbol symbol)
{
return(symbol.ToString().StartsWith("string.Format("));
}
private static bool IsSelectingADifferentMethod(IEnumerable <SyntaxNode> childNodes, SimpleNameSyntax methodName, SyntaxTree tree, IMethodSymbol methodSymbol, ExpressionSyntax invocationExpression, Compilation compilation)
{
var parameterExpressions = GetParameterExpressions(childNodes);
var firstArgument = parameterExpressions.FirstOrDefault();
var argumentList = CreateArgumentListSyntaxFrom(parameterExpressions.Skip(1));
var newInvocationStatement = CreateInvocationExpression(firstArgument, methodName, argumentList)
.WithAdditionalAnnotations(introduceExtensionMethodAnnotation);
var extensionMethodNamespaceUsingDirective = SyntaxFactory.UsingDirective(methodSymbol.ContainingNamespace.ToNameSyntax());
var speculativeRootWithExtensionMethod = tree.GetCompilationUnitRoot()
.ReplaceNode(invocationExpression, newInvocationStatement)
.AddUsings(extensionMethodNamespaceUsingDirective);
var speculativeTree = speculativeRootWithExtensionMethod.SyntaxTree;
var speculativeTreeOptions = (CSharpParseOptions)speculativeTree.Options;
var speculativeTreeWithCorrectLanguageVersion = speculativeTree.WithRootAndOptions(speculativeRootWithExtensionMethod, speculativeTreeOptions.WithLanguageVersion(((CSharpParseOptions)tree.Options).LanguageVersion));
var speculativeModel = compilation.ReplaceSyntaxTree(tree, speculativeTreeWithCorrectLanguageVersion)
.GetSemanticModel(speculativeTreeWithCorrectLanguageVersion);
var speculativeInvocationStatement = speculativeTreeWithCorrectLanguageVersion.GetCompilationUnitRoot().GetAnnotatedNodes(introduceExtensionMethodAnnotation).Single() as InvocationExpressionSyntax;
var speculativeExtensionMethodSymbol = speculativeModel.GetSymbolInfo(speculativeInvocationStatement.Expression).Symbol as IMethodSymbol;
var speculativeNonExtensionFormOfTheMethodSymbol = speculativeExtensionMethodSymbol?.GetConstructedReducedFrom();
return(speculativeNonExtensionFormOfTheMethodSymbol == null || speculativeNonExtensionFormOfTheMethodSymbol.ToString() != methodSymbol.ToString());//can't compare equality, as speculative symbol might be different
}
public static MethodBase ToCSharpMethod(this IMethodSymbol methodSymbol, List <NamedTypeBase> types, SemanticModel model, NamedTypeBase parentType, LoggerProvider logprovider)
{
if (methodSymbol == null)
{
return(null);
}
INamedType drt = null;
//hack
if (methodSymbol.ReturnType.TypeKind != TypeKind.TypeParameter)
{
drt = types.FirstOrDefault(t => t == methodSymbol.ReturnType.ToCSharpNamedType(logprovider));
if (drt == null && !methodSymbol.ReturnsVoid)
{
logprovider.WriteToLog(string.Format("Cannot find type for {0} as the non-void declared return type of method {1}, creating empty type manually", methodSymbol.ReturnType.ToString(), methodSymbol.ToString()));
types.Add(methodSymbol.ReturnType.ToCSharpNamedType(logprovider));
}
}
List <IMethodParameter> parameters = new List <IMethodParameter>();
foreach (var paramSymbol in methodSymbol.Parameters)
{
parameters.Add(paramSymbol.ToCSharpMethodParameter(types, logprovider));
}
return(new CSharpMethod
{
IsAbstract = methodSymbol.IsAbstract,
IsOverride = methodSymbol.IsOverride,
IsStatic = methodSymbol.IsStatic,
IsVirtual = methodSymbol.IsVirtual,
Parent = parentType,
Name = methodSymbol.Name,
IsCtor = (methodSymbol.MethodKind == MethodKind.Constructor),
Visibility = methodSymbol.DeclaredAccessibility.ToVisibilityModifierBase(logprovider),
DeclaredReturnType = drt,
Parameters = parameters,
ActualReturnTypes = methodSymbol.GetActualReturnTypes(types, model),
IsGeneric = methodSymbol.IsGenericMethod,
SourceSymbol = methodSymbol,
GenericParameters = CSharpModelBuilder.BuildGenericList(methodSymbol.TypeArguments)
});
}
public static string GetKeyValueFor(QueryContext queryContext)
{
Workspace Workspace = queryContext.workspace;
Project proj = queryContext.proj;
Document doc = queryContext.doc;
IMethodSymbol methodSymbol = queryContext.methodSymbol;
MethodDeclarationSyntax method = queryContext.method;
//Location location = queryContext.location;
//var invokes = method.DescendantNodes().Where(x=>x is InvocationExpressionSyntax).ToList();
String method_name = method.Identifier.Text;
String solution_id = Workspace.CurrentSolution.Id.Id.ToString();
String project_path = proj.FilePath;
String project_name = proj.Name;
String project_assemblypath = proj.AssemblyName;
String project_id = proj.Id.Id.ToString();
String document_id = doc.Id.Id.ToString();
String document_name = doc.Name.ToString();
String document_path = doc.FilePath.ToString();
String document_folders = string.Join(",", doc.Folders);
String textspan_start = method.Span.Start.ToString(); //location.GetMappedLineSpan().Span.Start.ToString();
String textspan_end = method.Span.End.ToString(); //location.GetMappedLineSpan().Span.End.ToString();
String hashCode = toHashCode(methodSymbol, new String[] { solution_id, project_id, document_id, doc.FilePath }).ToString();
// String method_parameter_list = method.ParameterList.Parameters.Select(x=>x.ToString());
String method_languge = method.Language;
int method_arity = method.Arity;
String method_declaration_line1 = "";
{
String methodstring = method.ToString();
if (methodstring.Contains("\n"))
{
var i = methodstring.IndexOf("\n");
method_declaration_line1 = methodstring.Substring(0, i + 1);
}
}
String method_symbol_name = methodSymbol.Name;
String method_symbol_defination = methodSymbol.ToString(); //Microsoft.CodeAnalysis.SemanticModel.GetSymbolInfo(Microsoft.CodeAnalysis.SyntaxNode, System.Threading.CancellationToken)
String method_symbol_orginal_defination = methodSymbol.OriginalDefinition.ToString();
String method_symbol_associated_symbol = "";
if (methodSymbol.AssociatedSymbol != null)
{
method_symbol_associated_symbol = methodSymbol.AssociatedSymbol.ToString();
}
String method_symbol_containing_module = methodSymbol.ContainingModule.ToString();
String method_symbol_containing_namespace = methodSymbol.ContainingNamespace.ToString();
String method_symbol_containing_assembly = methodSymbol.ContainingAssembly.ToString(); //ContainingAssembly
bool method_symbol_HidesBaseMethodsByName = methodSymbol.HidesBaseMethodsByName;
bool method_symbol_isAbstract = methodSymbol.IsAbstract;
bool method_symbol_isAsync = methodSymbol.IsAsync;
bool method_symbol_isGenericMethod = methodSymbol.IsGenericMethod;
bool method_symbol_isImplcitlyDeclared = methodSymbol.IsImplicitlyDeclared;
bool method_symbol_isOverride = methodSymbol.IsOverride;
bool method_symbol_isSealed = methodSymbol.IsSealed;
bool method_symbol_isStatic = methodSymbol.IsStatic;
bool method_symbol_isVirtual = methodSymbol.IsVirtual;
bool method_symbol_isExtern = methodSymbol.IsExtern;
String method_symbol_ReturnType = methodSymbol.ReturnType.ToString();
String className = methodSymbol.ContainingType.ToString();
String[] keys = new String[] {
"name",
"method_name",
"solution_id",
"project_path",
"project_name",
"project_id",
"document_id",
"document_name",
"document_path",
"document_folders",
"textspan_start",
"textspan_end",
"hashCode",
"method_arity",
"method_declaration_line1",
"method_symbol_name",
"method_symbol_defination",
"method_symbol_orginal_defination",
"method_symbol_associated_symbol",
"method_symbol_containing_module",
"method_symbol_containing_namespace",
"method_symbol_containing_assembly",
"method_symbol_associated_symbol",
"method_symbol_containing_module",
"method_symbol_containing_namespace",
"method_symbol_containing_assembly",
"method_symbol_HidesBaseMethodsByName",
"method_symbol_isAbstract",
"method_symbol_isAsync",
"method_symbol_isGenericMethod",
"method_symbol_isImplcitlyDeclared",
"method_symbol_isOverride",
"method_symbol_isSealed",
"method_symbol_isStatic",
"method_symbol_isVirtual",
"method_symbol_isExtern",
"method_symbol_ReturnType",
"class_name"
};
String[] values = new String[] {
hashCode,
method_name,
solution_id,
project_path,
project_name,
project_id,
document_id,
document_name,
document_path,
document_folders,
textspan_start,
textspan_end,
hashCode,
method_arity.ToString(),
method_declaration_line1,
method_symbol_name.ToString(),
method_symbol_defination.ToString(),
method_symbol_orginal_defination.ToString(),
method_symbol_associated_symbol,
method_symbol_containing_module,
method_symbol_containing_namespace,
method_symbol_containing_assembly,
method_symbol_associated_symbol,
method_symbol_containing_module,
method_symbol_containing_namespace,
method_symbol_containing_assembly,
method_symbol_HidesBaseMethodsByName.ToString(),
method_symbol_isAbstract.ToString(),
method_symbol_isAsync.ToString(),
method_symbol_isGenericMethod.ToString(),
method_symbol_isImplcitlyDeclared.ToString(),
method_symbol_isOverride.ToString(),
method_symbol_isSealed.ToString(),
method_symbol_isStatic.ToString(),
method_symbol_isVirtual.ToString(),
method_symbol_isExtern.ToString(),
method_symbol_ReturnType.ToString(),
className
};
String querypart = "";
for (int i = 0; i < values.Length; i++)
{
querypart += keys[i] + ":'" + values[i] + "',\n";
}
return(querypart);
}
public Task(IMethodSymbol symbol, bool step)
{
CheckSignature(symbol);
signature = symbol.ToString();
this.step = step;
}
public override string ToString()
{
return(Symbol.ToString());
}
static void CheckSignature(IMethodSymbol symbol)
{
bool hasDuplicateParameters = symbol.Parameters
.GroupBy(p => p.Name, StringComparer.OrdinalIgnoreCase)
.Any(p => p.Count() > 1);
if (!symbol.ReturnsVoid ||
symbol.IsGenericMethod ||
symbol.Parameters.Any(p => p.RefKind != RefKind.None || !TypeConverter.IsSupported(p.Type)) ||
hasDuplicateParameters)
throw new TaskSignatureViolationException(symbol.ToString());
}