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