private static Solution UpdateMainDocument(Document document, SyntaxNode root, MethodDeclarationSyntax method, IEnumerable<IGrouping<Document, ReferenceLocation>> documentGroups)
{
var mainDocGroup = documentGroups.FirstOrDefault(dg => dg.Key.Equals(document));
SyntaxNode newRoot;
if (mainDocGroup == null)
{
newRoot = root.ReplaceNode(method, method.AddModifiers(staticToken));
}
else
{
var diagnosticNodes = mainDocGroup.Select(referenceLocation => root.FindNode(referenceLocation.Location.SourceSpan)).ToList();
newRoot = root.TrackNodes(diagnosticNodes.Union(new[] { method }));
newRoot = newRoot.ReplaceNode(newRoot.GetCurrentNode(method), method.AddModifiers(staticToken));
foreach (var diagnosticNode in diagnosticNodes)
{
var token = newRoot.FindToken(diagnosticNode.GetLocation().SourceSpan.Start);
var tokenParent = token.Parent;
if (token.Parent.IsKind(SyntaxKind.IdentifierName)) continue;
var invocationExpression = newRoot.GetCurrentNode(diagnosticNode).FirstAncestorOrSelfOfType<InvocationExpressionSyntax>()?.Expression;
if (invocationExpression == null || invocationExpression.IsKind(SyntaxKind.IdentifierName)) continue;
var memberAccess = invocationExpression as MemberAccessExpressionSyntax;
if (memberAccess == null) continue;
var newMemberAccessParent = memberAccess.Parent.ReplaceNode(memberAccess, memberAccess.Name)
.WithAdditionalAnnotations(Formatter.Annotation);
newRoot = newRoot.ReplaceNode(memberAccess.Parent, newMemberAccessParent);
}
}
var newSolution = document.Project.Solution.WithDocumentSyntaxRoot(document.Id, newRoot);
return newSolution;
}
private static ClassDeclarationSyntax CreateParameterClass(string newNameClass, MethodDeclarationSyntax oldMethod)
{
var properties = CreateProperties(oldMethod);
return SyntaxFactory.ClassDeclaration(newNameClass)
.WithMembers(SyntaxFactory.List<MemberDeclarationSyntax>(properties))
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)));
}
private async Task<Document> ReturnVoidAsync(Document document, MethodDeclarationSyntax method, CancellationToken cancellationToken)
{
var newStatements = new List<StatementSyntax>();
foreach (var s in method.Body.Statements)
{
if (s is ReturnStatementSyntax)
{
continue;
}
else
newStatements.Add(s);
}
var newMethodDeclaration =
SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName("void").WithLeadingTrivia(method.ReturnType.GetLeadingTrivia()).WithTrailingTrivia(method.ReturnType.GetTrailingTrivia()), method.Identifier)
.AddModifiers(method.Modifiers.ToArray())
.WithLeadingTrivia(method.GetLeadingTrivia())
.WithBody(SyntaxFactory.Block(newStatements))
;
var root = await document.GetSyntaxRootAsync();
var newRoot = root.ReplaceNode(method, newMethodDeclaration);
return document.WithSyntaxRoot(newRoot);
}
private static StatementSyntax CreateStatement(MethodDeclarationSyntax methodNode, IMethodSymbol methodSymbol)
{
var methodParameters = methodSymbol.Parameters;
var arguments = new string[methodParameters.Length];
for(var i = 0; i < methodParameters.Length; i++)
{
var parameter = methodParameters[i];
var argument = parameter.Name;
if (parameter.RefKind.HasFlag(RefKind.Ref))
{
argument = $"ref {argument}";
}
else if (parameter.RefKind.HasFlag(RefKind.Out))
{
argument = $"out {argument}";
}
arguments[i] = argument;
}
var methodCall = $"base.{methodSymbol.Name}({string.Join(", ", arguments)});{Environment.NewLine}";
if(!methodSymbol.ReturnsVoid)
{
var variableName = MustInvokeBaseMethodCallMethodCodeFix.CreateSafeLocalVariableName(
methodNode, methodSymbol);
methodCall = $"var {variableName} = {methodCall}";
}
return SyntaxFactory.ParseStatement(methodCall).WithAdditionalAnnotations(Formatter.Annotation);
}
public void DetectBlockingAsyncCallers(MethodDeclarationSyntax node)
{
var symbol = SemanticModel.GetDeclaredSymbol(node);
if (symbol != null)
{
foreach (var refs in SymbolFinder.FindReferencesAsync(symbol, SourceFile.Project.Solution).Result)
{
foreach (var loc in refs.Locations)
{
var textSpan = loc.Location.SourceSpan;
var callerNode = loc.Document.GetSyntaxRootAsync().Result.DescendantNodes(textSpan).FirstOrDefault(n => textSpan.Contains(n.Span));
var callerText = loc.Document.GetTextAsync().Result.Lines.ElementAt(loc.Location.GetLineSpan().StartLinePosition.Line).ToString();
if (callerText.Contains(".Wait()")) // caller.Contains(".Result")
{
Logs.TempLog5.Info("Blocking Caller Name: " + callerText.Trim() + " from this file: " + loc.Document.FilePath);
var temp = callerNode != null ? callerNode.Ancestors().OfType<MethodDeclarationSyntax>().FirstOrDefault() : null;
if (temp != null)
{
Logs.TempLog5.Info("Blocking Caller Method Node: " + temp.ToLog());
if (temp.IsAsync())
{
Logs.TempLog5.Info("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
}
}
Logs.TempLog5.Info("Async method Callee from this file " + SourceFile.FilePath + node.ToLog()+ Logs.Break);
}
}
}
}
}
private async Task<Document> RepairXmlCommentAsync(Document document, MethodDeclarationSyntax methodSyntax, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var methodSymbol = model.GetDeclaredSymbol(methodSyntax);
var xml = methodSymbol.GetDocumentationCommentXml();
var documentTrivia = methodSyntax.GetLeadingTrivia().Where(n => n.Kind() == SyntaxKind.SingleLineDocumentationCommentTrivia).Last();
var documentText = documentTrivia.ToFullString().TrimEnd();
var invalidXml = Regex.Replace(documentText, @"^\s*///", "", RegexOptions.Multiline);
var newXml = RpairXml(invalidXml);
var newDocumentCommentText = Regex.Replace(newXml, @"^", "///", RegexOptions.Multiline) + "\r\n";
var newDocumentTrivia = SyntaxFactory.ParseLeadingTrivia(newDocumentCommentText)[0];
var newRoot = root.ReplaceTrivia(documentTrivia, newDocumentTrivia.WithAdditionalAnnotations(Formatter.Annotation));
var newDocument = document.WithSyntaxRoot(newRoot);
return newDocument;
}
private async Task<Document> RemoveAsyncAwait(Document document, MethodDeclarationSyntax methodDecl, CancellationToken cancellationToken)
{
MethodDeclarationSyntax newMethodDecl;
// (1) Remove async keyword
var asyncModifier = methodDecl.Modifiers.First(a => a.Kind() == SyntaxKind.AsyncKeyword);
newMethodDecl = asyncModifier.HasLeadingTrivia
? methodDecl.WithModifiers(methodDecl.Modifiers.Remove(asyncModifier)).WithLeadingTrivia(asyncModifier.LeadingTrivia)
: methodDecl.WithModifiers(methodDecl.Modifiers.Remove(asyncModifier));
// (2) If void, convert it to Task
if (newMethodDecl.ReturnsVoid())
{
var newType = SyntaxFactory.ParseTypeName("System.Threading.Tasks.Task").WithAdditionalAnnotations(Simplifier.Annotation).WithTrailingTrivia(newMethodDecl.ReturnType.GetTrailingTrivia());
newMethodDecl = newMethodDecl.WithReturnType(newType);
}
// (3) For all await expressions, remove await and insert return if there is none.
var awaitExprs = newMethodDecl.Body.DescendantNodes().OfType<AwaitExpressionSyntax>();
List<SyntaxReplacementPair> pairs = new List<SyntaxReplacementPair>();
foreach (var awaitExpr in awaitExprs)
{
SyntaxNode oldNode;
SyntaxNode newNode;
var newAwaitExpr = awaitExpr;
// If there is some ConfigureAwait(false), remove it
var invoc = awaitExpr.Expression as InvocationExpressionSyntax;
if (invoc != null)
{
var expr = invoc.Expression as MemberAccessExpressionSyntax;
// TODO: Check whether it is ConfigureAwait(false) or ConfigureAwait(true);
if (expr != null && expr.Name.Identifier.ValueText == "ConfigureAwait")
{
newAwaitExpr = awaitExpr.ReplaceNode(awaitExpr.Expression, expr.Expression);
}
}
if (awaitExpr.Parent.Kind() == SyntaxKind.ReturnStatement)
{
oldNode = awaitExpr;
newNode = newAwaitExpr.Expression.WithAdditionalAnnotations(Simplifier.Annotation);
}
else
{
oldNode = awaitExpr.Parent;
newNode = SyntaxFactory.ReturnStatement(newAwaitExpr.Expression).WithAdditionalAnnotations(Formatter.Annotation).WithTrailingTrivia(oldNode.GetTrailingTrivia());
}
pairs.Add(new SyntaxReplacementPair(oldNode, newNode));
}
newMethodDecl = newMethodDecl.ReplaceAll(pairs);
// (4) Replace the old method with the new one.
var root = await document.GetSyntaxRootAsync().ConfigureAwait(false);
var newRoot = root.ReplaceNode(methodDecl, newMethodDecl);
return document.WithSyntaxRoot(newRoot);
}
public void Run(object testObject, MethodDeclarationSyntax method, SemanticModel semanticModel)
{
_semanticModel = semanticModel;
ExecuteSetup(testObject, method);
ExecuteTest(testObject, method);
ExecuteTearDown(testObject, method);
}
public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
{
var parameterTokens = node.ParameterList.Parameters.Select(p => p.Identifier);
tracker.AddIdentifiers(parameterTokens);
Visit(node.Body);
tracker.RemoveIdentifiers(parameterTokens);
}
public CoverageResult CalculateForMethod(string projectName, MethodDeclarationSyntax method)
{
var projects = _testExplorer.GetUnignoredTestProjectsWithCoveredProjectsAsync().Result;
var project = projects.FirstOrDefault(x => x.Name == projectName);
if (project == null)
return new CoverageResult(new LineCoverage[0]);
var rewritter = new SolutionRewriter(new RewrittenDocumentsStorage(), _auditVariablesRewriter);
RewrittenDocument rewrittenDocument = rewritter.RewriteDocumentWithAssemblyInfo(project, projects, method.SyntaxTree.FilePath, method.SyntaxTree.ToString());
LineCoverage[] coverage = null;
using (var appDomainTestExecutorScriptEngine = new AppDomainTestExecutorScriptEngine())
{
var lineCoverageCalc = new LineCoverageCalc(_testExplorer, new RoslynCompiler(),
new TestRunner(new NUnitTestExtractor(), appDomainTestExecutorScriptEngine, _solutionExplorer));
coverage = lineCoverageCalc.CalculateForMethod(project, rewrittenDocument, method);
}
_coverageStore.Append(coverage);
return new CoverageResult(coverage);
}
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
{
// Not the correct way of getting rid of compiler generated getter/setter
if (node.AttributeLists.Any(attrList =>
attrList.Attributes.Any(attr =>
attr.Name.ToFullString().Contains("CompilerGeneratedAttribute")))||
node.Identifier.ToFullString().StartsWith("get_") ||
node.Identifier.ToFullString().StartsWith("set_") ||
node.Identifier.ToFullString().StartsWith("add_")||
node.Identifier.ToFullString().StartsWith("remove_"))
{
return null;
}
return base.VisitMethodDeclaration(
node.Update(
node.AttributeLists,
SyntaxFactory.TokenList(),
UpdateReturnType(node.ReturnType),
node.ExplicitInterfaceSpecifier,
node.Identifier,
UpdateTypeParameterList(node.TypeParameterList),
UpdateParameterList(node.ParameterList),
node.ConstraintClauses,
UpdateMethodBody(node.Body, node.ReturnType, node.ParameterList),
node.SemicolonToken
));
}
private Diagnostic HandleMethod(MethodDeclarationSyntax methodDeclaration)
{
if (methodDeclaration.ExpressionBody != null)
{
return null;
}
if (methodDeclaration.DescendantNodesAndTokensAndSelf().Any(x => x.GetLeadingTrivia().Concat(x.GetTrailingTrivia()).Any(y => !y.IsWhitespaceTrivia())))
{
return null;
}
if (methodDeclaration.Body?.Statements.Count != 1)
{
return null;
}
var statement = methodDeclaration.Body.Statements.FirstOrDefault();
var returnStatement = statement?.DescendantNodesAndSelf().OfType<ReturnStatementSyntax>().FirstOrDefault();
if (returnStatement == null)
{
return null;
}
return Diagnostic.Create(Rule, returnStatement.GetLocation(), "Method", methodDeclaration.Identifier.ValueText);
}
protected override string FindError(MethodDeclarationSyntax method)
{
var statements = method.Body.Statements;
return statements.Count != 1
|| !(statements.Single() is ReturnStatementSyntax)
? ShouldBeSingleMethodMessage : null;
}
private static async Task<Document> ReplacePropertyInDocumentAsync(Document document, MethodDeclarationSyntax method, MethodDeclarationSyntax newMethod, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = root.ReplaceNode(method, new[] { newMethod });
return document.WithSyntaxRoot(newRoot);
}
public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
{
if (node.HasEventArgsParameter())
Result.generalAsyncResults.NumEventHandlerMethods++;
base.VisitMethodDeclaration(node);
}
internal static MethodDeclarationSyntax CreateIEnumerableFromParamsArrayMethod(MetaField field, MethodDeclarationSyntax paramsArrayMethod)
{
return paramsArrayMethod
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Parameter(ValuesParameterName.Identifier)
.WithType(Syntax.IEnumerableOf(GetFullyQualifiedSymbolName(field.ElementType))))));
}
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax methodSyntax)
{
var leadingTrivia = methodSyntax.Identifier.LeadingTrivia;
var trailingTriva = methodSyntax.Identifier.TrailingTrivia;
return methodSyntax.ReplaceToken(methodSyntax.Identifier,
SyntaxFactory.Identifier(leadingTrivia, ToCamelCase(methodSyntax.Identifier.ValueText), trailingTriva));
}
public static PreconditionsBlock GetPreconditions(MethodDeclarationSyntax method, SemanticModel semanticModel)
{
Contract.Requires(method != null);
var preconditions = new List<IfThrowPrecondition>();
// Precondition block ends when something exception precondition check is met.
foreach (var statement in method.Body.Statements)
{
// Currently, If-throw precondition means that
// if statement has only one statement in the if block
// and this statement is a throw of type ArgumentException
var ifThrowStatement = statement as IfStatementSyntax;
if (ifThrowStatement == null) break;
var block = ifThrowStatement.Statement as BlockSyntax;
if (block != null && block.Statements.Count != 1) break;
var throwStatementCandidate = block != null ? block.Statements[0] : ifThrowStatement.Statement;
// The only valid case (when the processing should keep going)
// is when the if block has one statement and that statment is a throw of ArgumentException
if (IsThrowArgumentExceptionStatement(throwStatementCandidate, semanticModel))
{
preconditions.Add(new IfThrowPrecondition(statement, (ThrowStatementSyntax) throwStatementCandidate));
}
else
{
break;
}
}
return new PreconditionsBlock(preconditions);
}
public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
{
if (RequiresNullChecks(node.AttributeLists))
{
AddMessage(node, $"method {node.Identifier} needs null checks");
}
}
public void TestSetup()
{
syntaxTree = CSharpSyntaxTree.ParseText(Source);
ifMethod = syntaxTree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().First(m => m.Identifier.ValueText == "IfMethod");
switchMethod = syntaxTree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().First(m => m.Identifier.ValueText == "SwitchMethod");
}
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
{
var visibilityTokens = node.DescendantTokens(_ => true)
.Where(_ => _.IsKind(SyntaxKind.PublicKeyword) ||
_.IsKind(SyntaxKind.PrivateKeyword) ||
_.IsKind(SyntaxKind.ProtectedKeyword) ||
_.IsKind(SyntaxKind.InternalKeyword)).ToImmutableList();
if (!visibilityTokens.Any(_ => _.IsKind(SyntaxKind.PublicKeyword)))
{
var tokenPosition = 0;
var newMethod = node.ReplaceTokens(visibilityTokens,
(_, __) =>
{
tokenPosition++;
return tokenPosition == 1 ?
SyntaxFactory.Token(
_.LeadingTrivia,
SyntaxKind.PublicKeyword,
_.TrailingTrivia) :
new SyntaxToken();
});
return newMethod;
}
else
{
return node;
}
}
private static bool IsMethodAttributeAnException(MethodDeclarationSyntax methodDeclaration)
{
if (methodDeclaration == null) return false;
foreach (var attributeList in methodDeclaration.AttributeLists)
{
foreach (var attribute in attributeList.Attributes)
{
var identifierName = attribute.Name as IdentifierNameSyntax;
string nameText = null;
if (identifierName != null)
{
nameText = identifierName?.Identifier.Text;
}
else
{
var qualifiedName = attribute.Name as QualifiedNameSyntax;
if (qualifiedName != null)
nameText = qualifiedName.Right?.Identifier.Text;
}
if (nameText == null) continue;
if (IsExcludedAttributeName(nameText)) return true;
}
}
return false;
}
public LineCoverage[] RunTest(Project project,
RewrittenDocument rewrittenDocument,
MethodDeclarationSyntax method,
ISemanticModel semanticModel,
string[] rewrittenAssemblies)
{
var testClass = method.GetParentClass();
var rewrittenTestClass =
rewrittenDocument.SyntaxTree
.GetRoot()
.DescendantNodes()
.OfType<ClassDeclarationSyntax>().First(x => x.Identifier.ToString() == testClass.Identifier.ToString());
var fixtureDetails = _testsExtractor.GetTestFixtureDetails(rewrittenTestClass, semanticModel);
var allReferences = _solutionExplorer.GetAllProjectReferences(project.Name);
fixtureDetails.Cases.RemoveAll(x => x.MethodName != method.Identifier.ToString());
if (fixtureDetails.Cases.Count == 0)
return null;
var compiledTestInfo = new CompiledTestFixtureInfo
{
AllReferences = allReferences.Union(rewrittenAssemblies).ToArray(),
TestDocumentPath = rewrittenDocument.DocumentPath,
SemanticModel = semanticModel
};
var coverage = RunTestFixture(fixtureDetails, compiledTestInfo, project.Name);
return coverage;
}
private static List<PropertyDeclarationSyntax> NewPropertyClassFactory(MethodDeclarationSyntax methodOld)
{
var newGetSyntax = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
var newSetSyntax = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
var acessorSyntax = SyntaxFactory.AccessorList(
SyntaxFactory.Token(SyntaxKind.OpenBraceToken),
SyntaxFactory.List(new[] { newGetSyntax, newSetSyntax }),
SyntaxFactory.Token(SyntaxKind.CloseBraceToken));
var properties = new List<PropertyDeclarationSyntax>();
foreach (ParameterSyntax param in methodOld.ParameterList.Parameters)
{
var property = SyntaxFactory.PropertyDeclaration(
default(SyntaxList<AttributeListSyntax>),
SyntaxFactory.TokenList(new[] { SyntaxFactory.Token(SyntaxKind.PublicKeyword) }),
param.Type,
default(ExplicitInterfaceSpecifierSyntax),
SyntaxFactory.Identifier(FirstLetteToUpper(param.Identifier.Text)),
acessorSyntax);
properties.Add(property);
}
return properties;
}
private void AnalyzeMethodCodeBlock(CodeBlockAnalysisContext context, MethodDeclarationSyntax methodDeclarationSyntax)
{
if (HasMultipleIndentations(methodDeclarationSyntax.Body))
{
context.ReportDiagnostic(Diagnostic.Create(Rule, methodDeclarationSyntax.Identifier.GetLocation(), methodDeclarationSyntax.Identifier.Text));
}
}
private Task<Solution> MakePublicAsync(Document document, SyntaxNode root, MethodDeclarationSyntax method)
{
var generator = SyntaxGenerator.GetGenerator(document);
var newMethod = generator.WithAccessibility(method, Accessibility.Public);
var newRoot = root.ReplaceNode(method, newMethod);
return Task.FromResult(document.WithSyntaxRoot(newRoot).Project.Solution);
}
private SyntaxNode FixMethod(
bool keepVoid, IMethodSymbol methodSymbol, MethodDeclarationSyntax method,
ITypeSymbol taskType, INamedTypeSymbol taskOfTType)
{
var newReturnType = method.ReturnType;
if (methodSymbol.ReturnsVoid)
{
if (!keepVoid)
{
newReturnType = taskType.GenerateTypeSyntax();
}
}
else
{
if (!IsTaskLike(methodSymbol.ReturnType, taskType, taskOfTType))
{
// If it's not already Task-like, then wrap the existing return type
// in Task<>.
newReturnType = taskOfTType.Construct(methodSymbol.ReturnType).GenerateTypeSyntax();
}
}
var newModifiers = method.Modifiers.Add(s_asyncToken);
return method.WithReturnType(newReturnType).WithModifiers(newModifiers);
}
private SyntaxToken AnnotationResolver(
SyntaxNode node,
TriviaLocation location,
SyntaxAnnotation annotation,
SyntaxNode callsite,
MethodDeclarationSyntax method)
{
var token = node.GetAnnotatedNodesAndTokens(annotation).FirstOrDefault().AsToken();
if (token.RawKind != 0)
{
return token;
}
switch (location)
{
case TriviaLocation.BeforeBeginningOfSpan:
return callsite.GetFirstToken(includeZeroWidth: true).GetPreviousToken(includeZeroWidth: true);
case TriviaLocation.AfterEndOfSpan:
return callsite.GetLastToken(includeZeroWidth: true).GetNextToken(includeZeroWidth: true);
case TriviaLocation.AfterBeginningOfSpan:
return method.Body.OpenBraceToken.GetNextToken(includeZeroWidth: true);
case TriviaLocation.BeforeEndOfSpan:
return method.Body.CloseBraceToken.GetPreviousToken(includeZeroWidth: true);
}
return Contract.FailWithReturn<SyntaxToken>("can't happen");
}
public static List<ValidatorResult> Validate(MethodDeclarationSyntax methodSyntax, IAsyncRewriterLogger log, CompilationLookup extensionMethodLookup, SemanticModel semanticModel, HashSet<ITypeSymbol> excludeTypes, ITypeSymbol cancellationTokenSymbol)
{
var validator = new AsyncMethodValidator(log, extensionMethodLookup, semanticModel, excludeTypes, cancellationTokenSymbol, methodSyntax);
validator.Visit(methodSyntax);
return validator.results;
}
public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
{
MethodWalker walker = this.CreateSyntaxWalker<MethodWalker>(node);
walker.Visit(node);
this.Methods.Add(walker);
base.VisitMethodDeclaration(node);
}
public static glsl.FunctionDeclarationSyntax Translate(this cs.MethodDeclarationSyntax node)
{
var functionDeclaration = new glsl.FunctionDeclarationSyntax();
return(functionDeclaration.Update(
Translate(node.ReturnType),
node.Identifier,
Translate(node.ParameterList),
Translate(node.Body)
));
}
public override void VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax node)
{
base.VisitMethodDeclaration(node);
var body = node.Body;
// partial/abstract method
if (body == null)
{
return;
}
VisitBody("Method", node.Identifier, body, semanticModel.GetDeclaredSymbol(node));
}
public override void VisitMethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax node)
{
var symbol = semanticModel.GetDeclaredSymbol(node);
if (symbol != null && IsInactiveConditional(symbol))
{
Colorize(node, inactiveCodeColor);
}
else
{
base.VisitMethodDeclaration(node);
Colorize(node.Identifier, methodDeclarationColor);
}
}
public static List <string> GetAttributesForMethod(CSharpSyntax.MethodDeclarationSyntax node)
{
var attributesList = new List <string>();
foreach (CSharpSyntax.AttributeListSyntax attributeList in node.AttributeLists)
{
foreach (CSharpSyntax.AttributeSyntax attribute in attributeList.Attributes)
{
attributesList.Add(attribute.Name.GetText().ToString());
}
}
return(attributesList);
}
public override VisualBasicSyntaxNode VisitMethodDeclaration(CSS.MethodDeclarationSyntax node)
{
SyntaxList <StatementSyntax>?block = null;
if (node.Body != null)
{
block = SyntaxFactory.List(node.Body.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this))));
}
var id = SyntaxFactory.Identifier(node.Identifier.ValueText, SyntaxFacts.IsKeywordKind(node.Identifier.Kind()), node.Identifier.GetIdentifierText(), TypeCharacter.None);
var methodInfo = semanticModel.GetDeclaredSymbol(node);
if (methodInfo?.GetReturnType()?.SpecialType == SpecialType.System_Void)
{
var stmt = SyntaxFactory.SubStatement(
SyntaxFactory.List(node.AttributeLists.Select(a => (AttributeListSyntax)a.Accept(this))),
ConvertModifiers(node.Modifiers, TokenContext.Member),
id, (TypeParameterListSyntax)node.TypeParameterList?.Accept(this),
(ParameterListSyntax)node.ParameterList?.Accept(this),
null, null, null
);
if (block == null)
{
return(stmt);
}
return(SyntaxFactory.SubBlock(stmt, block.Value));
}
else
{
var stmt = SyntaxFactory.FunctionStatement(
SyntaxFactory.List(node.AttributeLists.Select(a => (AttributeListSyntax)a.Accept(this))),
ConvertModifiers(node.Modifiers, TokenContext.Member),
id, (TypeParameterListSyntax)node.TypeParameterList?.Accept(this),
(ParameterListSyntax)node.ParameterList?.Accept(this),
SyntaxFactory.SimpleAsClause((TypeSyntax)node.ReturnType.Accept(this)), null, null
);
if (block == null)
{
return(stmt);
}
return(SyntaxFactory.FunctionBlock(stmt, block.Value));
}
}
public static List <CSharpSyntax.AttributeSyntax> GetAttributesByName(string attributeName,
CSharpSyntax.MethodDeclarationSyntax node)
{
var attributesList = new List <CSharpSyntax.AttributeSyntax>();
if (node?.AttributeLists == null)
{
return(attributesList);
}
foreach (CSharpSyntax.AttributeListSyntax attributeList in node.AttributeLists)
{
foreach (CSharpSyntax.AttributeSyntax attribute in attributeList.Attributes)
{
if (attribute.Name.GetText().ToString().Equals(attributeName))
{
attributesList.Add(attribute);
}
}
}
return(attributesList);
}
private static void AnalyzeMethodTypeSymbol(SymbolAnalysisContext context, IMethodSymbol symbol)
{
if (symbol.MethodKind == MethodKind.PropertyGet ||
symbol.MethodKind == MethodKind.PropertySet)
{
// Property getters/setters are handled via IPropertySymbol
return;
}
if (IsInternal(context, symbol.ReturnType))
{
foreach (var declaringSyntax in symbol.DeclaringSyntaxReferences)
{
var location = declaringSyntax.GetSyntax() switch
{
CSharpSyntax.MethodDeclarationSyntax s => s.ReturnType.GetLocation(),
{ } otherSyntax => otherSyntax.GetLocation()
};
context.ReportDiagnostic(Diagnostic.Create(_descriptor, location, symbol.ReturnType));
}
}
foreach (var paramSymbol in symbol.Parameters.Where(ps => IsInternal(context, ps.Type)))
{
foreach (var declaringSyntax in paramSymbol.DeclaringSyntaxReferences)
{
var location = declaringSyntax.GetSyntax() switch
{
CSharpSyntax.ParameterSyntax s when s.Type != null => s.Type.GetLocation(),
{ } otherSyntax => otherSyntax.GetLocation()
};
context.ReportDiagnostic(Diagnostic.Create(_descriptor, location, paramSymbol.Type));
}
}
}
public virtual void VisitEndMethodDeclaration(CSharpSyntax.MethodDeclarationSyntax node, ExecutionState state)
{
}
public override void VisitEndMethodDeclaration(CSharpSyntax.MethodDeclarationSyntax node, ExecutionState state)
{
CheckState(state);
}
