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));
}
