public override SyntaxNode VisitClassBlock(ClassBlockSyntax originalNode)
{
var node = (ClassBlockSyntax)base.VisitClassBlock(originalNode);
var begin = (ClassStatementSyntax)EnsureVisibility(node.ClassStatement, node.ClassStatement.Modifiers, (x, l) => x.WithModifiers(l), () => GetTypeDefaultVisibility(originalNode));
return(node.WithClassStatement(begin));
}
private void Update(CodeContext context, ClassBlockSyntax modelClass, INamedTypeSymbol modelType)
{
Update(context);
ModelClass = modelClass;
ModelType = modelType;
BaseModel = ResolveBaseModel();
}
public override void VisitClassBlock(ClassBlockSyntax node)
{
if (TryAddPublicApi(node.ClassStatement))
{
base.VisitClassBlock(node);
}
}
public NamespaceBuilderResult BuildNamespacesForFundingLines(IDictionary <string, Funding> funding,
int decimalPlaces = 2)
{
NamespaceBuilderResult result = new NamespaceBuilderResult
{
PropertiesDefinitions = Array.Empty <StatementSyntax>(),
EnumsDefinitions = Array.Empty <StatementSyntax>()
};
foreach (string @namespace in funding.Keys)
{
ClassBlockSyntax @class = SyntaxFactory.ClassBlock(
SyntaxFactory.ClassStatement(
_typeIdentifierGenerator.GenerateIdentifier($"{@namespace}FundingLines")
)
.WithModifiers(
SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword))),
new SyntaxList <InheritsStatementSyntax>(),
new SyntaxList <ImplementsStatementSyntax>(),
SyntaxFactory.List(CreateFundingLineClass(funding[@namespace].FundingLines.DistinctBy(_ => _.Id), @namespace, decimalPlaces)),
SyntaxFactory.EndClassStatement()
);
result.InnerClasses.Add(new NamespaceClassDefinition(_typeIdentifierGenerator.GenerateIdentifier(@namespace), @class, "FundingLines", "FundingLines"));
}
return(result);
}
private NamespaceClassDefinition CreateNamespaceDefinition(
string @namespace,
IEnumerable <Calculation> calculationsInNamespace,
IEnumerable <StatementSyntax> propertyDefinitions,
IEnumerable <string> propertyAssignments,
string className = null)
{
ClassStatementSyntax classStatement = SyntaxFactory
.ClassStatement(className ?? $"{@namespace}Calculations")
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)));
SyntaxList <InheritsStatementSyntax> inherits = SyntaxFactory.SingletonList(SyntaxFactory.InheritsStatement(_compilerOptions.UseLegacyCode
? SyntaxFactory.ParseTypeName("LegacyBaseCalculation")
: SyntaxFactory.ParseTypeName("BaseCalculation")));
IEnumerable <StatementSyntax> namespaceFunctionPointers = CreateNamespaceFunctionPointers(calculationsInNamespace);
StatementSyntax initialiseMethodDefinition = CreateInitialiseMethod(calculationsInNamespace, propertyAssignments, className);
ClassBlockSyntax classBlock = SyntaxFactory.ClassBlock(classStatement,
inherits,
new SyntaxList <ImplementsStatementSyntax>(),
SyntaxFactory.List(propertyDefinitions
.Concat(namespaceFunctionPointers)
.Concat(new[]
{
initialiseMethodDefinition
}).ToArray()),
SyntaxFactory.EndClassStatement());
return(new NamespaceClassDefinition(@namespace, classBlock));
}
public override void VisitClassBlock(ClassBlockSyntax node)
{
if (_targetPatternRegEx.Match(node.ClassStatement.Identifier.ToString()).Success)
{
RecordMatchAndContext(node, BlockType.ClassBlock);
}
base.VisitClassBlock(node);
}
internal static CodeStructureItem MapItem(ClassBlockSyntax node)
{
var item = CreateItem <ClassNode>(node);
item.AccessModifier = node.ClassStatement.Modifiers.GetAccessModifier();
item.Name = node.ClassStatement.Identifier.Text;
return(item);
}
public override SyntaxNode VisitClassBlock(ClassBlockSyntax node)
=> generator.AddMembers(
base.VisitClassBlock(node),
generator.FieldDeclaration(
"_mock",
ParseTypeName(nameof(IMock)),
initializer: generator.ObjectCreationExpression(
ParseTypeName(nameof(MockInfo)))
));
public NamespaceClassDefinition(string @namespace,
ClassBlockSyntax classBlockSyntax,
string variable = null,
string suffix = "Calculations")
{
Variable = (variable == null ? @namespace : $"{@namespace}.{variable}");
Namespace = @namespace;
Suffix = suffix;
ClassBlockSyntax = classBlockSyntax;
}
private static void GenerateStaticConstructor(DocumentEditor editor, ClassBlockSyntax classDeclaration,
string registerPropertyMethodName, IPropertySymbol propertySymbol, bool returnsMounter, CancellationToken ct)
{
var semanticModel = editor.SemanticModel;
var classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration, ct);
var staticConstructor = editor.Generator.GeneratePropertyRegistration(LanguageNames.VisualBasic, classSymbol, propertySymbol, registerPropertyMethodName, returnsMounter, false);
var index = GetMounterDeclarationInsertIndex(classDeclaration, semanticModel);
editor.InsertMembers(classDeclaration, index, new SyntaxNode[] { staticConstructor });
}
private static void GenerateMounterFieldDeclaration(DocumentEditor editor, string registerPropertyMethodName,
ClassBlockSyntax classDeclaration, IPropertySymbol propertySymbol, CancellationToken ct)
{
var semanticModel = editor.SemanticModel;
var classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration, ct);
var mounterDeclaration = editor.Generator.GenerateMounterDeclaration(LanguageNames.VisualBasic, classSymbol, propertySymbol, registerPropertyMethodName);
var index = GetMounterDeclarationInsertIndex(classDeclaration, semanticModel);
editor.InsertMembers(classDeclaration, index, new SyntaxNode[] { mounterDeclaration });
}
protected override TypeBlockSyntax CreateTopLevelTypeDeclaration(IEnumerable <StatementSyntax> members)
{
ClassBlockSyntax classDecl = (ClassBlockSyntax)base.CreateTopLevelTypeDeclaration(members);
TypeSyntax[] typeArr = new TypeSyntax[] { InheritsType };
InheritsStatementSyntax[] inheritArr = new InheritsStatementSyntax[] { SyntaxFactory.InheritsStatement(typeArr) };
SyntaxList <InheritsStatementSyntax> inherits = SyntaxFactory.List(inheritArr);
classDecl = classDecl.WithInherits(inherits);
return(classDecl);
}
public IEnumerable <SourceFile> GenerateCalcs(IEnumerable <Calculation> calculations, IDictionary <string, Funding> funding)
{
SyntaxList <OptionStatementSyntax> optionsList = new SyntaxList <OptionStatementSyntax>(new[]
{
SyntaxFactory.OptionStatement(SyntaxFactory.Token(SyntaxKind.StrictKeyword),
SyntaxFactory.Token(_compilerOptions.OptionStrictEnabled ? SyntaxKind.OnKeyword : SyntaxKind.OffKeyword))
});
SyntaxList <ImportsStatementSyntax> standardImports = StandardImports();
string identifier = _typeIdentifierGenerator.GenerateIdentifier("CalculationContext");
SyntaxTokenList modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
ClassStatementSyntax classStatement = SyntaxFactory
.ClassStatement(identifier)
.WithModifiers(modifiers);
SyntaxList <InheritsStatementSyntax> inherits = SyntaxFactory.SingletonList(SyntaxFactory.InheritsStatement(_compilerOptions.UseLegacyCode
? SyntaxFactory.ParseTypeName("LegacyBaseCalculation")
: SyntaxFactory.ParseTypeName("BaseCalculation")));
IEnumerable <StatementSyntax> methods = CreateMembers(calculations, funding);
ClassBlockSyntax classBlock = SyntaxFactory.ClassBlock(classStatement,
inherits,
new SyntaxList <ImplementsStatementSyntax>(),
SyntaxFactory.List(methods),
SyntaxFactory.EndClassStatement());
SyntaxList <StatementSyntax> members = SyntaxFactory.SingletonList <StatementSyntax>(classBlock);
CompilationUnitSyntax syntaxTree = SyntaxFactory.CompilationUnit().WithOptions(optionsList);
syntaxTree = syntaxTree.WithImports(standardImports);
syntaxTree = syntaxTree.WithMembers(members);
try
{
syntaxTree = syntaxTree.NormalizeWhitespace();
}
catch (Exception e)
{
throw new Exception($"Error compiling source code. Please check your code's structure is valid. {e.Message}", e);
}
string sourceCode = syntaxTree.ToFullString();
yield return(new SourceFile {
FileName = "Calculations.vb", SourceCode = sourceCode
});
}
public override SyntaxNode VisitClassBlock(ClassBlockSyntax node)
{
var result = generator.AddInterfaceType(
base.VisitClassBlock(node),
generator.IdentifierName(nameof(IMocked)));
result = generator.AddMembers(result,
generator.FieldDeclaration("_mock", ParseTypeName(nameof(IMock)))
.WithLeadingTrivia(Whitespace(Environment.NewLine)));
var property = (PropertyBlockSyntax)generator.PropertyDeclaration(
nameof(IMocked.Mock),
ParseTypeName(nameof(IMock)),
modifiers: DeclarationModifiers.ReadOnly,
getAccessorStatements: new[]
{
generator.ReturnStatement(
generator.InvocationExpression(
generator.MemberAccessExpression(
generator.IdentifierName(nameof(LazyInitializer)),
nameof(LazyInitializer.EnsureInitialized)),
generator.Argument(
RefKind.Ref,
generator.IdentifierName("_mock")),
ParenthesizedExpression(
SingleLineFunctionLambdaExpression(
FunctionLambdaHeader(List <AttributeListSyntax>(), TokenList(), ParameterList(), null),
ObjectCreationExpression(
List <AttributeListSyntax>(),
IdentifierName(nameof(MockInfo)),
ArgumentList(SingletonSeparatedList <ArgumentSyntax>(
SimpleArgument(MeExpression())
)),
null
)
)
)
)
)
});
property = property.WithPropertyStatement(
property.PropertyStatement.WithImplementsClause(
ImplementsClause(QualifiedName(IdentifierName(nameof(IMocked)), IdentifierName(nameof(IMocked.Mock))))));
result = generator.AddMembers(result, property);
return(result);
}
private MethodStatementSyntax GetIncrementTokenMethodDeclaration(ClassBlockSyntax classBlock)
{
foreach (var member in classBlock.Members.Where(m => m.IsKind(SyntaxKind.FunctionBlock)))
{
var functionBlock = (MethodBlockSyntax)member;
var methodDeclaration = (MethodStatementSyntax)functionBlock.BlockStatement;
if (methodDeclaration.Identifier.ValueText == "IncrementToken")
{
return(methodDeclaration);
}
}
return(null);
}
public override SyntaxNode VisitClassBlock(ClassBlockSyntax node)
{
var result = base.VisitClassBlock(node);
if (!generator.GetBaseAndInterfaceTypes(result).Any(x =>
x.ToString() == nameof(IStunt) ||
x.ToString() == typeof(IStunt).FullName))
{
// Only add the base type if it isn't already there
result = generator.AddInterfaceType(
result,
generator.IdentifierName(nameof(IStunt)));
}
if (!generator.GetMembers(result).Any(x => generator.GetName(x) == nameof(IStunt.Behaviors)))
{
var property = (PropertyBlockSyntax)generator.PropertyDeclaration(
nameof(IStunt.Behaviors),
GenericName("ObservableCollection", TypeArgumentList(IdentifierName(nameof(IStuntBehavior)))),
modifiers: DeclarationModifiers.ReadOnly,
getAccessorStatements: new[]
{
generator.ReturnStatement(
generator.MemberAccessExpression(
IdentifierName("pipeline"),
nameof(BehaviorPipeline.Behaviors)))
});
property = property.WithPropertyStatement(
property.PropertyStatement.WithImplementsClause(
ImplementsClause(QualifiedName(IdentifierName(nameof(IStunt)), IdentifierName(nameof(IStunt.Behaviors))))));
result = generator.InsertMembers(result, 0, property);
}
if (!generator.GetMembers(result).Any(x => generator.GetName(x) == "pipeline"))
{
var field = generator.FieldDeclaration(
"pipeline",
generator.IdentifierName(nameof(BehaviorPipeline)),
modifiers: DeclarationModifiers.ReadOnly,
initializer: generator.ObjectCreationExpression(generator.IdentifierName(nameof(BehaviorPipeline))));
result = generator.InsertMembers(result, 0, field);
}
return(result);
}
private static int GetMounterDeclarationInsertIndex(ClassBlockSyntax classDeclaration, SemanticModel semanticModel)
{
var members = classDeclaration.Members;
var lastMounterDeclaration = -1;
for (int i = 0; i < members.Count; i++)
{
if (IsMounterDeclaration(members[i], semanticModel))
{
lastMounterDeclaration = i;
}
}
return(lastMounterDeclaration + 1);
}
public override ITypeSymbol GetEnclosingTypeSymbol(SyntaxNode node, SemanticModel semanticModel)
{
if (node == null)
{
return(null);
}
ClassBlockSyntax declaration = node.AncestorsAndSelf().OfType <ClassBlockSyntax>().FirstOrDefault();
if (declaration == null)
{
return(null);
}
return(semanticModel.GetDeclaredSymbol(declaration));
}
public IEnumerable <SourceFile> GenerateDatasets(BuildProject buildProject)
{
ClassBlockSyntax wrapperSyntaxTree = SyntaxFactory.ClassBlock(SyntaxFactory.ClassStatement("Datasets")
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword))));
if (buildProject.DatasetRelationships != null)
{
HashSet <string> typesCreated = new HashSet <string>();
foreach (DatasetRelationshipSummary dataset in buildProject.DatasetRelationships)
{
if (!typesCreated.Contains(dataset.DatasetDefinition.Name))
{
ClassBlockSyntax @class = SyntaxFactory.ClassBlock(
SyntaxFactory.ClassStatement(
$"{GenerateIdentifier(dataset.DatasetDefinition.Name)}Dataset"
)
.WithModifiers(
SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword))),
new SyntaxList <InheritsStatementSyntax>(),
new SyntaxList <ImplementsStatementSyntax>(),
SyntaxFactory.List(GetMembers(dataset.DatasetDefinition)),
SyntaxFactory.EndClassStatement()
);
CompilationUnitSyntax syntaxTree = SyntaxFactory.CompilationUnit()
.WithImports(StandardImports())
.WithMembers(
SyntaxFactory.SingletonList <StatementSyntax>(@class))
.NormalizeWhitespace();
yield return(new SourceFile {
FileName = $"Datasets/{GenerateIdentifier(dataset.DatasetDefinition.Name)}.vb", SourceCode = syntaxTree.ToFullString()
});
typesCreated.Add(dataset.DatasetDefinition.Name);
}
wrapperSyntaxTree =
wrapperSyntaxTree.WithMembers(SyntaxFactory.List(buildProject.DatasetRelationships.Select(GetDatasetProperties)));
}
}
yield return(new SourceFile {
FileName = $"Datasets/Datasets.vb", SourceCode = wrapperSyntaxTree.NormalizeWhitespace().ToFullString()
});
}
private static void GenerateRegistrationStatement(DocumentEditor editor, ClassBlockSyntax classDeclaration, ConstructorBlockSyntax staticConstructor,
string registerPropertyMethodName, IPropertySymbol propertySymbol, bool returnsMounter, CancellationToken ct)
{
var semanticModel = editor.SemanticModel;
var classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration, ct);
var statements = staticConstructor.Statements;
if (statements.Count > 0)
{
var statement = editor.Generator.GeneratePropertyRegistration(LanguageNames.VisualBasic, classSymbol, propertySymbol, registerPropertyMethodName, returnsMounter, true);
editor.InsertAfter(statements.Last(), new SyntaxNode[] { statement });
}
else
{
var newStaticConstructor = editor.Generator.GeneratePropertyRegistration(LanguageNames.VisualBasic, classSymbol, propertySymbol, registerPropertyMethodName, returnsMounter, false);
editor.ReplaceNode(staticConstructor, newStaticConstructor);
}
}
public override SyntaxNode VisitClassBlock(ClassBlockSyntax node)
{
node = (ClassBlockSyntax)rewriter.VisitClass(node);
// Turn event fields into event declarations.
var events = node.ChildNodes().OfType <EventStatementSyntax>().ToArray();
node = node.RemoveNodes(events, SyntaxRemoveOptions.KeepNoTrivia);
foreach (var e in events)
{
var valueParam = ParameterList().AddParameters(Parameter(ModifiedIdentifier("value")).WithAsClause(e.AsClause));
var statements = List <StatementSyntax>(new[]
{
ExpressionStatement((ExpressionSyntax)generator.ExecutePipeline(null, valueParam.Parameters))
});
node = node.AddMembers(new[]
{
EventBlock(e.WithCustomKeyword(Token(SyntaxKind.CustomKeyword)), List(new[]
{
AddHandlerAccessorBlock(
AccessorStatement(SyntaxKind.AddHandlerAccessorStatement, Token(SyntaxKind.AddHandlerKeyword))
.WithParameterList(valueParam))
.WithStatements(statements),
RemoveHandlerAccessorBlock(
AccessorStatement(SyntaxKind.RemoveHandlerAccessorStatement, Token(SyntaxKind.RemoveHandlerKeyword))
.WithParameterList(valueParam))
.WithStatements(statements),
RaiseEventAccessorBlock(
AccessorStatement(SyntaxKind.RaiseEventAccessorStatement, Token(SyntaxKind.RaiseEventKeyword))
.WithParameterList(ParameterList().AddParameters(
Parameter(ModifiedIdentifier("sender")).WithAsClause(SimpleAsClause(PredefinedType(Token(SyntaxKind.ObjectKeyword)))),
Parameter(ModifiedIdentifier("args")).WithAsClause(SimpleAsClause(IdentifierName(nameof(EventArgs)))))))
}))
});
}
return(base.VisitClassBlock(node));
}
private static void AnalyzeCandidateKey(SyntaxNodeAnalysisContext context, ClassBlockSyntax classBlock)
{
var semanticModel = context.SemanticModel;
var classSymbol = semanticModel.GetDeclaredSymbol(classBlock);
if (!IsCandidateKey(context, classSymbol))
{
return;
}
var constructorParams = VerifyConstructor(context, classSymbol, out var constructorSymbol);
if (constructorParams.IsEmpty)
{
return;
}
var subNewStatement = (SubNewStatementSyntax)constructorSymbol.DeclaringSyntaxReferences[0].GetSyntax();
var constructorBlock = (ConstructorBlockSyntax)subNewStatement.Parent;
VerifyBaseConstructorInitializer(context, constructorBlock, constructorParams);
}
private static bool AnyDuplicate(InvocationExpressionSyntax invocationExpression, IPropertySymbol propertySymbol, ClassBlockSyntax classBlock, SemanticModel semanticModel)
{
var result = GetPropertyRegistration(propertySymbol, classBlock, semanticModel);
return(result == null ? false : CompareLocation(invocationExpression, result) > 0);
}
private static void GenerateRegisterChildModel(DocumentEditor editor, ConstructorBlockSyntax staticConstructor, ClassBlockSyntax classDeclaration,
SemanticModel semanticModel, IPropertySymbol childProperty, IPropertySymbol foreignKey)
{
if (staticConstructor == null)
{
var newStaticConstructor = editor.Generator.GenerateChildModelRegistrationStaticConstructor(LanguageNames.VisualBasic, childProperty, foreignKey);
var index = GetMounterDeclarationInsertIndex(classDeclaration, semanticModel);
editor.InsertMembers(classDeclaration, index, new SyntaxNode[] { newStaticConstructor });
}
else
{
var statements = staticConstructor.Statements;
if (statements.Count > 0)
{
var statement = editor.Generator.GenerateChildModelRegistration(LanguageNames.VisualBasic, childProperty, foreignKey);
editor.InsertAfter(statements.Last(), new SyntaxNode[] { statement });
}
else
{
var newStaticConstructor = editor.Generator.GenerateChildModelRegistrationStaticConstructor(LanguageNames.VisualBasic, childProperty, foreignKey);
editor.ReplaceNode(staticConstructor, newStaticConstructor);
}
}
}
public override void VisitClassBlock(ClassBlockSyntax node)
{
LogicalLineCount++;
base.VisitClassBlock(node);
}
public override SyntaxNode VisitClassBlock(ClassBlockSyntax node)
{
var result = base.VisitClassBlock(node);
if (!generator.GetBaseAndInterfaceTypes(result).Any(x =>
x.ToString() == nameof(IMocked) ||
x.ToString() == typeof(IMocked).FullName))
{
// Only add the base type if it isn't already there
result = generator.AddInterfaceType(result, generator.IdentifierName(nameof(IMocked)));
}
if (!generator.GetMembers(result).Any(x => generator.GetName(x) == "_mock"))
{
var field = generator.FieldDeclaration("_mock", ParseTypeName(nameof(IMock)))
.WithTrailingTrivia(CarriageReturnLineFeed);
// Try to locate the _mock field following the pipeline field
var pipeline = generator.GetMembers(result).FirstOrDefault(x => generator.GetName(x) == "pipeline");
if (pipeline != null)
{
result = generator.InsertNodesAfter(result, pipeline, new[] { field });
}
else
{
result = generator.InsertMembers(result, 0, field
.WithLeadingTrivia(ElasticTab, ElasticTab));
}
}
if (!generator.GetMembers(result).Any(x => generator.GetName(x) == nameof(IMocked.Mock)))
{
var property = (PropertyBlockSyntax)generator.PropertyDeclaration(
nameof(IMocked.Mock),
ParseTypeName(nameof(IMock)),
modifiers: DeclarationModifiers.ReadOnly,
getAccessorStatements: new[]
{
generator.ReturnStatement(
generator.InvocationExpression(
generator.MemberAccessExpression(
generator.IdentifierName(nameof(LazyInitializer)),
nameof(LazyInitializer.EnsureInitialized)),
generator.Argument(
RefKind.Ref,
generator.IdentifierName("_mock")),
ParenthesizedExpression(
SingleLineFunctionLambdaExpression(
FunctionLambdaHeader(List <AttributeListSyntax>(), TokenList(), ParameterList(), null),
ObjectCreationExpression(
List <AttributeListSyntax>(),
IdentifierName(nameof(DefaultMock)),
ArgumentList(SingletonSeparatedList <ArgumentSyntax>(
SimpleArgument(MeExpression())
)),
null
)
)
)
)
)
});
property = property.WithPropertyStatement(
property.PropertyStatement.WithImplementsClause(
ImplementsClause(QualifiedName(IdentifierName(nameof(IMocked)), IdentifierName(nameof(IMocked.Mock))))));
// Try to locate the Mock property following the Behaviors property
var behaviors = generator.GetMembers(result).FirstOrDefault(x => generator.GetName(x) == nameof(IStunt.Behaviors));
if (behaviors != null)
{
result = generator.InsertNodesAfter(result, behaviors, new[] { property });
}
else
{
result = generator.AddMembers(result, property);
}
}
return(result);
}
private Class TraverseClass(ClassBlockSyntax cbs)
{
Class retClass = new Class();
//Name
retClass.Name = cbs.Begin.Identifier.ValueText;
//encapsulation
foreach (SyntaxToken st in cbs.Begin.Modifiers)
{
string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
Encapsulation encap;
Qualifiers qual;
if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
{
retClass.Encapsulation.Add(encap);
}
else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
{
retClass.Qualifiers.Add(qual);
}
}
List<EnumBlockSyntax> enums = new List<EnumBlockSyntax>();
List<StructureBlockSyntax> structs = new List<StructureBlockSyntax>();
List<MethodBlockSyntax> methods = new List<MethodBlockSyntax>();
List<FieldDeclarationSyntax> Fields = new List<FieldDeclarationSyntax>();
List<PropertyBlockSyntax> properties = new List<PropertyBlockSyntax>();
List<ConstructorBlockSyntax> constructors = new List<ConstructorBlockSyntax>();
List<ModuleBlockSyntax> modules = new List<ModuleBlockSyntax>();
List<ClassBlockSyntax> classes = new List<ClassBlockSyntax>();
foreach (SyntaxNode sn in cbs.ChildNodes())
{
if (sn is EnumBlockSyntax)
{
enums.Add(sn as EnumBlockSyntax);
}
else if (sn is StructureBlockSyntax)
{
structs.Add(sn as StructureBlockSyntax);
}
else if (sn is MethodBlockSyntax)
{
methods.Add(sn as MethodBlockSyntax);
}
else if (sn is FieldDeclarationSyntax)
{
Fields.Add(sn as FieldDeclarationSyntax);
}
else if (sn is PropertyBlockSyntax)
{
properties.Add(sn as PropertyBlockSyntax);
}
else if (sn is ConstructorBlockSyntax)
{
constructors.Add(sn as ConstructorBlockSyntax);
}
else if (sn is ModuleBlockSyntax)
{
modules.Add(sn as ModuleBlockSyntax);
}
else if (sn is ClassBlockSyntax)
{
classes.Add(sn as ClassBlockSyntax);
}
}
foreach (EnumBlockSyntax ebs in enums)
{
//traverse enums
retClass.Enums.Add(TraverseEnum(ebs));
}
foreach (StructureBlockSyntax sbs in structs)
{
retClass.Structs.Add(TraverseStruct(sbs));
}
foreach (MethodBlockSyntax mbs in methods)
{
bool isConstructor = false;
Method tempMethod = TraverseMethod(mbs, ref isConstructor);
if (isConstructor)
{
retClass.Constructors.Add(tempMethod as Constructor);
}
else
{
retClass.Methods.Add(tempMethod);
}
}
foreach (FieldDeclarationSyntax fds in Fields)
{
retClass.Fields.Add(TraverseField(fds));
}
foreach (PropertyBlockSyntax pbs in properties)
{
retClass.Properties.Add(TraverseProperties(pbs));
}
foreach (ConstructorBlockSyntax css in constructors)
{
retClass.Constructors.Add(TraverseConstructor(css));
}
foreach (ModuleBlockSyntax mbs in modules)
{
retClass.Modules.Add(TraverseModule(mbs));
}
foreach (ClassBlockSyntax cbs2 in classes)
{
retClass.Classes.Add(TraverseClass(cbs2));
}
foreach (SyntaxNode sn in cbs.Begin.ChildNodes())
{
if (sn is InheritsOrImplementsStatementSyntax)
{
}
}
return retClass;
}
private static InvocationExpressionSyntax GetPropertyRegistration(IPropertySymbol propertySymbol, ClassBlockSyntax classBlock, SemanticModel semanticModel)
{
var members = classBlock.Members;
for (int i = 0; i < members.Count; i++)
{
var member = members[i];
if (member is ConstructorBlockSyntax constructorBlock)
{
var result = GetPropertyRegistration(propertySymbol, constructorBlock, semanticModel);
if (result != null)
{
return(result);
}
}
if (member is FieldDeclarationSyntax fieldDeclaration)
{
var result = GetPropertyRegistration(propertySymbol, fieldDeclaration, semanticModel);
if (result != null)
{
return(result);
}
}
}
return(null);
}
public override void VisitClassBlock(ClassBlockSyntax node)
{
var statementNode = node.ChildNodes().OfType <ClassStatementSyntax>().FirstOrDefault();
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 startLength = node.Span.Start;
var endLength = node.Span.End;
var parentNamespace = GetNamespace(DefineKinds.Class, startLength, endLength);
var baseTypeInfos = new List <BaseTypeInfo>();
// 継承元クラス、またはインターフェースがある場合
var hasInherits = node.ChildNodes().OfType <InheritsStatementSyntax>().Any();
var hasImplements = node.ChildNodes().OfType <ImplementsStatementSyntax>().Any();
if (hasInherits || hasImplements)
{
var baseTypes = new List <SyntaxNode>();
if (hasInherits)
{
var inheritsNode = node.ChildNodes().OfType <InheritsStatementSyntax>().FirstOrDefault();
var childNodes = inheritsNode.ChildNodes();
// Class の場合、多重継承はできない仕様だが、将来仕様変更されるか？されないと思う
foreach (var childNode in childNodes)
{
baseTypes.Add(childNode);
}
}
if (hasImplements)
{
var implementsNode = node.ChildNodes().OfType <ImplementsStatementSyntax>().FirstOrDefault();
var childNodes = implementsNode.ChildNodes();
foreach (var childNode in childNodes)
{
baseTypes.Add(childNode);
}
}
baseTypeInfos = GetBaseTypeInfos(baseTypes, parentNamespace);
}
UserDefinitions.Add(new UserDefinition
{
DefineKinds = DefineKinds.Class,
IsPartial = isPartial,
Namespace = parentNamespace,
DefineName = defineName,
DefineFullName = $"{parentNamespace}.{defineName}",
BaseTypeInfos = baseTypeInfos,
SourceFile = SourceFile,
StartLength = startLength,
EndLength = endLength,
});
base.VisitClassBlock(node);
}
public override void VisitClassBlock(ClassBlockSyntax node)
{
}
public override void VisitClassBlock(ClassBlockSyntax node)
{
AddBlockData(node);
base.VisitClassBlock(node);
}
