internal static CodeStructureItem MapItem(MethodBlockSyntax node) { var item = CreateItem <MethodNode>(node); item.AccessModifier = node.SubOrFunctionStatement.Modifiers.GetAccessModifier(); item.Name = node.SubOrFunctionStatement.Identifier.Text; return(item); }
public override void VisitMethodBlock(MethodBlockSyntax node) { if (_targetPatternRegEx.Match(node.SubOrFunctionStatement.Identifier.ToString()).Success) { RecordMatchAndContext(node, BlockType.MethodBlock); } base.VisitMethodBlock(node); }
public override SyntaxNode VisitMethodBlock(MethodBlockSyntax node) { if (generator.GetAttributes(node).Any(attr => generator.GetName(attr) == "CompilerGenerated")) { return(base.VisitMethodBlock(node)); } return(base.VisitMethodBlock((MethodBlockSyntax)AddAttributes(node))); }
/// <summary> /// Entry point that visit the method statements. /// </summary> /// <param name="node"></param> /// <param name="state"></param> /// <returns></returns> private VariableState VisitMethodDeclaration(MethodBlockSyntax node, ExecutionState state) { foreach (ParameterSyntax parameter in node.SubOrFunctionStatement.ParameterList.Parameters) { state.AddNewValue(ResolveIdentifier(parameter.Identifier.Identifier), new VariableState(parameter, VariableTaint.Tainted)); } return(VisitBlock(node, state)); }
public override void VisitMethodBlock(MethodBlockSyntax node) { parent.currentMethod = node.SubOrFunctionStatement; base.VisitMethodBlock(node); if (parent.hasDirectRecursiveCall) { parent.IncreaseComplexity(node.SubOrFunctionStatement.Identifier, 1, "+1 (recursion)"); } }
private bool TryGetToStringMethod(TypeBlockSyntax cds, out MethodBlockSyntax toStringMethod) { toStringMethod = cds.Members .OfType <MethodBlockSyntax>() .FirstOrDefault(p => p.SubOrFunctionStatement.Identifier.ValueText == "ToString" && p.SubOrFunctionStatement.ParameterList.Parameters.Count == 0 && p.SubOrFunctionStatement.Modifiers.Any(SyntaxKind.PublicKeyword) && p.SubOrFunctionStatement.Modifiers.Any(SyntaxKind.OverridesKeyword)); return(toStringMethod != null); }
public override Microsoft.CodeAnalysis.SyntaxNode VisitMethodBlock(MethodBlockSyntax node) { MethodBlockSyntax newNode = null; EmptyStatementSyntax emptyNode = SyntaxFactory.EmptyStatement(); if (_targetPatternRegEx.Match(node.SubOrFunctionStatement.Identifier.ToString()).Success) { try { if (_commentOutOnly) { List <SyntaxTrivia> newTrivia = new List <SyntaxTrivia>(); string existingLeadingTrivia = node.GetLeadingTrivia().ToString(); string existingLeadingTriviaFull = node.GetLeadingTrivia().ToFullString(); string existingTrailingTrivia = node.GetTrailingTrivia().ToString(); string existingTrailingTriviaFull = node.GetTrailingTrivia().ToFullString(); string startOfLineWhiteSpace = existingLeadingTrivia.Replace(System.Environment.NewLine, ""); newTrivia.Add(SyntaxFactory.CommentTrivia(existingLeadingTriviaFull)); newTrivia.Add(SyntaxFactory.CommentTrivia(VNCCA.Helpers.VB.MultiLineComment(_comment, startOfLineWhiteSpace))); newTrivia.Add(SyntaxFactory.CommentTrivia("' ")); // Comment out the whole method. newTrivia.Add(SyntaxFactory.CommentTrivia(VNCCA.Helpers.VB.BlockComment(node.ToFullString()))); return(emptyNode.WithLeadingTrivia(newTrivia)); // We don't need the existing node as it has been completely commented out. //newNode = node.WithLeadingTrivia(newTrivia); } else { // This removes the node newNode = null; } } catch (Exception ex) { Messages.AppendLine(string.Format("Ex:{0} InnerEx:{1}", ex.ToString(), ex.InnerException.ToString())); } } else { newNode = node; } return(newNode); }
public override SyntaxNode VisitMethodBlock(MethodBlockSyntax node) { if (node.SubOrFunctionStatement.Identifier.ToString() == "_Execute") { var statements = m_userCode.GetRoot().ChildNodes();//.OfType<StatementSyntax>(); SyntaxList <SyntaxNode> syntaxList = new SyntaxList <SyntaxNode>(statements); return(base.VisitMethodBlock(node.WithStatements(syntaxList))); } else { return(base.VisitMethodBlock(node)); } }
private static ObjectCreationExpressionSyntax GetConstructorExpression(MethodBlockSyntax methodBlock) { var statements = methodBlock.Statements; if (statements.Count != 1) { return(null); } if (!(statements[0] is ReturnStatementSyntax returnStatement)) { return(null); } return(returnStatement.Expression as ObjectCreationExpressionSyntax); }
public override SyntaxNode VisitMethodBlock(MethodBlockSyntax node) { if (replaceDetails.Count == 0) { return(node); } var name = $"{_namespace}.{_class}.{node.SubOrFunctionStatement.Identifier.GetIdentifierText()}"; if (!replaceDetails.ContainsKey(name)) { return(node); } _methodName = name; return(base.VisitMethodBlock(node)); }
private bool IsFinalizer(MethodBlockSyntax methodBlockSyntax) { if (methodBlockSyntax == null) { return(false); } var subOrFunctionDeclaration = methodBlockSyntax.SubOrFunctionStatement; var noParam = subOrFunctionDeclaration.ParameterList == null || subOrFunctionDeclaration.ParameterList.Parameters.Count == 0; var noTypeParam = subOrFunctionDeclaration.TypeParameterList == null || subOrFunctionDeclaration.TypeParameterList.Parameters.Count == 0; var isSub = subOrFunctionDeclaration.SubOrFunctionKeyword.IsKind(SyntaxKind.SubKeyword); var isProtected = subOrFunctionDeclaration.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword)); return(noParam && noTypeParam && isSub && isProtected && subOrFunctionDeclaration.Identifier.ValueText.Equals("Finalize", StringComparison.InvariantCultureIgnoreCase)); }
public override SyntaxNode VisitMethodBlock(MethodBlockSyntax node) { var outParams = node.BlockStatement.ParameterList.Parameters.Where(x => x.Modifiers.Any(SyntaxKind.OutKeyword)).ToArray(); var refParams = node.BlockStatement.ParameterList.Parameters.Where(x => x.Modifiers.Any(SyntaxKind.ByRefKeyword)).ToArray(); if (outParams.Length != 0 || refParams.Length != 0) { node = (MethodBlockSyntax)generator.ImplementMethod(node, generator.GetType(node), outParams, refParams); } else { node = (MethodBlockSyntax)generator.ImplementMethod(node, generator.GetType(node)); } return(base.VisitMethodBlock(node)); }
/// <summary> /// Entry point that visit the method statements. /// </summary> /// <param name="node"></param> /// <param name="state"></param> /// <returns></returns> private VariableState VisitMethodDeclaration(MethodBlockSyntax node, ExecutionState state) { foreach (ParameterSyntax parameter in node.SubOrFunctionStatement.ParameterList.Parameters) { state.AddNewValue(ResolveIdentifier(parameter.Identifier.Identifier), new VariableState(parameter, VariableTaint.Tainted)); } foreach (StatementSyntax statement in node.Statements) { VisitNode(statement, state); foreach (var ext in Extensions) { ext.VisitStatement(statement, state); } } //The state return is irrelevant because it is not use. return(new VariableState(node, VariableTaint.Unknown)); }
private VariableState VisitMethodDeclaration(MethodBlockSyntax node, ExecutionState state) { foreach (ParameterSyntax statement in node.BlockStatement.ParameterList.Parameters) { state.AddNewValue(ResolveIdentifier(statement.Identifier.Identifier), new VariableState(statement, VariableTaint.TAINTED)); } if (node != null) { foreach (StatementSyntax statement in node.Statements) { VisitNode(statement, state); foreach (var ext in extensions) { ext.VisitStatement(statement, state); } } } //The state return is irrelevant because it is not use. return(new VariableState(node, VariableTaint.UNKNOWN)); }
public override IMethodSymbol GetCallerMethodSymbol(SyntaxNode node, SemanticModel semanticModel) { if (node == null) { return(null); } MethodBlockSyntax declaration = node.AncestorsAndSelf().OfType <MethodBlockSyntax>().FirstOrDefault(); if (declaration != null) { return(semanticModel.GetDeclaredSymbol(declaration)); } SubNewStatementSyntax constructor = node.AncestorsAndSelf().OfType <SubNewStatementSyntax>().FirstOrDefault(); if (constructor != null) { return(semanticModel.GetDeclaredSymbol(constructor)); } return(null); }
public override SyntaxNode VisitMethodBlock(MethodBlockSyntax node) { for (int a = 0; a < node.Statements.Count; a++) { if (node.Statements[a].IsKind(SyntaxKind.LocalDeclarationStatement)) { var initInvocations = new SyntaxList <StatementSyntax>(); foreach (var d in (node.Statements[a] as LocalDeclarationStatementSyntax).Declarators) { if (StructuresWithInitializer.Contains( d?.AsClause?.Type().WithoutTrivia().ToString())) { foreach (var name in d.Names) { if (name.ArrayBounds != null) { initInvocations = initInvocations.Add(CreateInitializer(name.Identifier.ToFullString().Trim(), d.AsClause.Type().WithoutTrivia().ToString(), true)); } else { initInvocations = initInvocations.Add(CreateInitializer(name.Identifier.ToFullString().Trim(), d.AsClause.Type().WithoutTrivia().ToString(), false)); } } } } foreach (var i in initInvocations) { node = node.WithStatements(node.Statements.Insert(a + 1, i.WithTrailingTrivia(SyntaxFactory.SyntaxTrivia(SyntaxKind.EndOfLineTrivia, Environment.NewLine)))); } } } return(base.VisitMethodBlock(node)); }
private Method TraverseMethod(MethodBlockSyntax mbs, ref bool isConstructor) { Method retMethod = new Method(); //get the MethodStatementSyntax MethodStatementSyntax methodss = null; foreach (SyntaxNode sn in mbs.ChildNodes()) { if (sn is MethodStatementSyntax) { methodss = sn as MethodStatementSyntax; break; } else if (sn is ConstructorBlockSyntax) { return TraverseConstructor(sn as ConstructorBlockSyntax); } } if (methodss == null) { throw new Exception("Bad MethodBlockStatement!"); } if (methodss != null) { retMethod.Name = methodss.Identifier.ValueText; } /* Preprocessors = new List<Preprocessor>(); Encapsulation = new List<Encapsulation>(); Base = new List<InvokedMethod>(); ReturnType = new Type(); Qualifiers = new List<Qualifiers>(); Parameters = new List<Variables>(); Decisions = new Decisions(); AccessedVariables = new List<Variables>(); LabelStatements = new List<LabelStatement>(); GoToStatements = new List<GoTo>(); InvokedMethods = new List<InvokedMethod>(); */ //Encapsulation foreach (SyntaxToken st in methodss.Modifiers) { string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText); Encapsulation encap; Qualifiers qual; if (System.Enum.TryParse<Encapsulation>(modifier, out encap)) { retMethod.Encapsulation.Add(encap); } else if (System.Enum.TryParse<Qualifiers>(modifier, out qual)) { retMethod.Qualifiers.Add(qual); } } //TODO: Need to determine what the qualifers are //TODO: Qualifiers ParameterListSyntax pls = methodss.ParameterList; //Parameters foreach (ParameterSyntax ps in pls.Parameters) { retMethod.Parameters.Add(TraverseParameters(ps)); } //Decisions List<MultiLineIfBlockSyntax> multiIfStms = new List<MultiLineIfBlockSyntax>(); List<SingleLineIfStatementSyntax> ifStms = new List<SingleLineIfStatementSyntax>(); List<ElseStatementSyntax> elseStm = new List<ElseStatementSyntax>(); List<ForEachStatementSyntax> foreachStm = new List<ForEachStatementSyntax>(); List<ForBlockSyntax> forStm = new List<ForBlockSyntax>(); List<DoLoopBlockSyntax> doWhileStm = new List<DoLoopBlockSyntax>(); List<WhileBlockSyntax> whileStm = new List<WhileBlockSyntax>(); List<SelectBlockSyntax> switchStm = new List<SelectBlockSyntax>(); List<CatchPartSyntax> catchStmm = new List<CatchPartSyntax>(); //Access Variables List<LocalDeclarationStatementSyntax> accessVarDefs = new List<LocalDeclarationStatementSyntax>(); List<AssignmentStatementSyntax> accessVars = new List<AssignmentStatementSyntax>(); //Label Statements List<LabelStatementSyntax> labelStms = new List<LabelStatementSyntax>(); //GoTo Statements List<GoToStatementSyntax> gotoStms = new List<GoToStatementSyntax>(); //InvokedMethods List<CallStatementSyntax> invokedMethods = new List<CallStatementSyntax>(); List<InvocationExpressionSyntax> invokedMethods2 = new List<InvocationExpressionSyntax>(); //Returns List<ReturnStatementSyntax> returns = new List<ReturnStatementSyntax>(); foreach (SyntaxNode sn in mbs.Statements) { if (sn is MultiLineIfBlockSyntax) { multiIfStms.Add(sn as MultiLineIfBlockSyntax); } if (sn is SingleLineIfStatementSyntax) { ifStms.Add(sn as SingleLineIfStatementSyntax); } else if (sn is ElseStatementSyntax) { elseStm.Add(sn as ElseStatementSyntax); } else if (sn is ForEachStatementSyntax) { foreachStm.Add(sn as ForEachStatementSyntax); } else if (sn is ForBlockSyntax) { forStm.Add(sn as ForBlockSyntax); } else if (sn is DoLoopBlockSyntax) { doWhileStm.Add(sn as DoLoopBlockSyntax); } else if (sn is WhileBlockSyntax) { whileStm.Add(sn as WhileBlockSyntax); } else if (sn is SelectBlockSyntax) { switchStm.Add(sn as SelectBlockSyntax); } else if (sn is CatchPartSyntax) { catchStmm.Add(sn as CatchPartSyntax); } else if (sn is LocalDeclarationStatementSyntax) { accessVarDefs.Add(sn as LocalDeclarationStatementSyntax); } else if (sn is AssignmentStatementSyntax) { accessVars.Add(sn as AssignmentStatementSyntax); } else if (sn is LabelStatementSyntax) { labelStms.Add(sn as LabelStatementSyntax); } else if (sn is LabelStatementSyntax) { gotoStms.Add(sn as GoToStatementSyntax); } else if (sn is GoToStatementSyntax) { gotoStms.Add(sn as GoToStatementSyntax); } else if (sn is CallStatementSyntax) { invokedMethods.Add(sn as CallStatementSyntax); } else if (sn is InvocationExpressionSyntax) { invokedMethods2.Add(sn as InvocationExpressionSyntax); } else if (sn is ReturnStatementSyntax) { returns.Add(sn as ReturnStatementSyntax); } } foreach (MultiLineIfBlockSyntax mlbs in multiIfStms) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = AllDecisions(TraverseMultiIfStatement(mlbs, ref exitPoints)); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } foreach (SingleLineIfStatementSyntax iss in ifStms) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = AllDecisions(TraverseIfStatement(iss, ref exitPoints)); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } foreach (ElseStatementSyntax ess in elseStm) { int exitPoints = retMethod.ExitPoints; retMethod.Decisions.ElseStatements.Add(TravsereElseStatement(ess, ref exitPoints)); retMethod.ExitPoints = exitPoints; } foreach (ForEachStatementSyntax fess in foreachStm) { int exitPoints = retMethod.ExitPoints; retMethod.Decisions.ForEachStatements.Add(TraverseForeachStatement(fess, ref exitPoints)); retMethod.ExitPoints = exitPoints; } foreach (ForBlockSyntax fss in forStm) { int exitPoints = retMethod.ExitPoints; Decisions tempDecision = AllDecisions(TraverseForStatement(fss, ref exitPoints)); retMethod.Decisions.IfStatements.AddRange(tempDecision.IfStatements); retMethod.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements); retMethod.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements); retMethod.Decisions.ForStatements.AddRange(tempDecision.ForStatements); retMethod.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops); retMethod.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops); retMethod.Decisions.Catches.AddRange(tempDecision.Catches); retMethod.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements); retMethod.ExitPoints = exitPoints; } foreach (DoLoopBlockSyntax dss in doWhileStm) { int exitPoints = retMethod.ExitPoints; retMethod.Decisions.DoWhileLoops.Add(TraverseDoWhileLoop(dss, ref exitPoints)); retMethod.ExitPoints = exitPoints; } foreach (WhileBlockSyntax wbs in whileStm) { int exitPoints = retMethod.ExitPoints; retMethod.Decisions.WhileLoops.Add(TraverseWhileLoop(wbs, ref exitPoints)); retMethod.ExitPoints = exitPoints; } foreach (SelectBlockSyntax sbs in switchStm) { int exitPoints = retMethod.ExitPoints; retMethod.Decisions.SwitchStatements.Add(TraverseSwitchStatement(sbs, ref exitPoints)); retMethod.ExitPoints = exitPoints; } foreach (CatchPartSyntax cps in catchStmm) { int exitPoints = retMethod.ExitPoints; retMethod.Decisions.Catches.Add(TraverseCatchStatement(cps, ref exitPoints)); retMethod.ExitPoints = exitPoints; } foreach (LocalDeclarationStatementSyntax vds in accessVarDefs) { Method tempMethod = TraverseVarDecls(vds); retMethod.AccessedVariables.AddRange(tempMethod.AccessedVariables); retMethod.InvokedMethods.AddRange(tempMethod.InvokedMethods); } foreach (AssignmentStatementSyntax vns in accessVars) { Method tempMethod = TraverseAccessVars(vns); retMethod.AccessedVariables.AddRange(tempMethod.AccessedVariables); retMethod.InvokedMethods.AddRange(tempMethod.InvokedMethods); } foreach (LabelStatementSyntax lss in labelStms) { retMethod.LabelStatements.Add(TraverseLabel(lss)); } foreach (GoToStatementSyntax gtss in gotoStms) { retMethod.GoToStatements.Add(TraverseGoTo(retMethod.LabelStatements, gtss)); } foreach (CallStatementSyntax mss in invokedMethods) { retMethod.InvokedMethods.Add(TraverseInvokedMethod(mss)); } foreach (InvocationExpressionSyntax ies in invokedMethods2) { retMethod.InvokedMethods.Add(TraverseInvokedMethod(ies)); } return retMethod; }
private async Task <Document> ReplaceToStringAsync(Document document, TypeBlockSyntax typeDec, MethodBlockSyntax oldToString, CancellationToken cancellationToken) { var newClassDec = typeDec.ReplaceNode(oldToString, GetToStringDeclarationSyntax(typeDec)); var sr = await document.GetSyntaxRootAsync(cancellationToken); var nsr = sr.ReplaceNode(typeDec, newClassDec); return(document.WithSyntaxRoot(nsr)); }
private static void AnalyzePrimaryKeyCreation(SyntaxNodeAnalysisContext context, MethodBlockSyntax methodDeclaration) { var semanticModel = context.SemanticModel; var methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration); var parameters = methodSymbol.GetKeyConstructorParams(context.Compilation, out _); if (parameters.IsDefaultOrEmpty) { return; } var arguments = methodDeclaration.GetKeyConstructorArguments(parameters); if (arguments == null) { return; } for (int i = 0; i < arguments.Length; i++) { var argument = arguments[i]; if (!(semanticModel.GetSymbolInfo(argument.GetExpression()).Symbol is IPropertySymbol propertySymbol) || propertySymbol.ContainingType != methodSymbol.ContainingType) { context.ReportDiagnostic(Diagnostic.Create(Rules.CandidateKeyInvalidArgument, argument.GetLocation())); }
private async Task RegisterReplaceToString(CodeRefactoringContext context, TypeBlockSyntax tds, MethodBlockSyntax toStringMethod) { semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); var action = CodeAction.Create(Strings.ReplaceToString, c => ReplaceToStringAsync(context.Document, tds, toStringMethod, c)); context.RegisterRefactoring(action); }
private static bool HasImplementation(MethodBlockSyntax methodBlock) => methodBlock.Statements.Count > 0;
// SubBlock, FunctionBlock が含まれているか? public override void VisitMethodBlock(MethodBlockSyntax node) { AddBlockData(node); base.VisitMethodBlock(node); }
public override void VisitMethodBlock(MethodBlockSyntax node) { LogicalLineCount++; base.VisitMethodBlock(node); }
// SubBlock, FunctionBlock が含まれているか? public override void VisitMethodBlock(MethodBlockSyntax node) { var statementNode = node.ChildNodes().OfType <MethodStatementSyntax>().FirstOrDefault(); var isSubMethod = statementNode.ChildTokens().Any(x => x.Kind() == SyntaxKind.SubKeyword); var isPartial = statementNode.ChildTokens().Any(x => x.Kind() == SyntaxKind.PartialKeyword); var defineName = statementNode.ChildTokens().FirstOrDefault(x => x.Kind() == SyntaxKind.IdentifierToken).ToString(); // ジェネリック型を定義している場合 if (statementNode.ChildNodes().OfType <TypeParameterListSyntax>().Any()) { var listNode = statementNode.ChildNodes().OfType <TypeParameterListSyntax>().FirstOrDefault(); var genericTypes = listNode .ChildNodes() .OfType <TypeParameterSyntax>() .Select(x => x.ChildTokens().FirstOrDefault(y => y.Kind() == SyntaxKind.IdentifierToken).ToString()); defineName = $"{defineName}<{string.Join(", ", genericTypes)}>"; } var methodArguments = new List <MethodArgument>(); if (statementNode.ChildNodes().OfType <ParameterListSyntax>().FirstOrDefault().ChildNodes().Any()) { var listNode = statementNode.ChildNodes().OfType <ParameterListSyntax>().FirstOrDefault(); methodArguments = GetMethodArguments(listNode); } var returnType = string.Empty; if (!isSubMethod) { var asNode = statementNode.ChildNodes().FirstOrDefault(x => x is SimpleAsClauseSyntax); returnType = asNode.ChildNodes().FirstOrDefault().ToString(); } var startLength = node.Span.Start; var endLength = node.Span.End; var parentNamespace = GetNamespace(DefineKinds.Method, startLength, endLength); // EventHandler、Method(Sub, Function) var isEventHandler = false; if (isSubMethod) { if (methodArguments.Count == 2) { if (methodArguments[0].DefineType == "Object" && methodArguments[1].DefineType.EndsWith("EventArgs")) { isEventHandler = true; } } } UserDefinitions.Add(new UserDefinition { DefineKinds = isEventHandler ? DefineKinds.EventHandler : DefineKinds.Method, IsPartial = isPartial, Namespace = parentNamespace, DefineName = defineName, DefineFullName = $"{parentNamespace}.{defineName}", MethodArguments = methodArguments, ReturnType = ConvertCSharpType(returnType), SourceFile = SourceFile, StartLength = startLength, EndLength = endLength, }); base.VisitMethodBlock(node); }
public static ArgumentSyntax[] GetKeyConstructorArguments(this MethodBlockSyntax methodBlock, ImmutableArray <IParameterSymbol> constructorParams) { var constructorExpression = GetConstructorExpression(methodBlock); return(constructorExpression == null ? null : GetConstructorArguments(constructorExpression, constructorParams)); }