internal GenericParameterDeclarationWithCodeAnalysis() { node = new Node <GenericParameterDeclarationWithCodeAnalysis, GenericParameterDeclarationSyntax>(this); attributes = new AttributeListWrapper <GenericParameterDeclarationWithCodeAnalysis, GenericParameterDeclarationSyntax>( node, syntax => syntax.TypeParameter.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); baseClassConstraint = CreateConstraintList( node, name => !interfaceMatch.IsMatch(name) && !genericParameterMatch.IsMatch(name), type => new ClassReferenceWithCodeAnalysis(type)); genericParameterConstraints = CreateConstraintList( node, name => genericParameterMatch.IsMatch(name), type => new GenericParameterReferenceWithCodeAnalysis(type)); interfaceConstraints = CreateConstraintList( node, name => interfaceMatch.IsMatch(name), type => new InterfaceReferenceWithCodeAnalysis(type)); members = new MemberList <GenericParameterDeclarationWithCodeAnalysis, GenericParameterDeclarationSyntax, TypeParameterConstraintSyntax>( node, (parentSyntax, childSyntax) => parentSyntax.WithConstraints(SyntaxFactory.SeparatedList(childSyntax))) { { nameof(BaseClassConstraint), () => baseClassConstraint.Select(item => item.TypeReference.Node.GetParent <TypeParameterConstraintSyntax>()) }, { nameof(GenericParameterConstraints), () => genericParameterConstraints.Select(item => item.TypeReference.Node.GetParent <TypeParameterConstraintSyntax>()) }, { nameof(InterfaceConstraints), () => interfaceConstraints.Select(item => item.TypeReference.Node.GetParent <TypeParameterConstraintSyntax>()) } }; }
internal EventPropertyWithCodeAnalysis() { node = new Node <EventPropertyWithCodeAnalysis, EventDeclarationSyntax>(this); addAttributes = new AttributeListWrapper <EventPropertyWithCodeAnalysis, EventDeclarationSyntax>( node, syntax => syntax.GetAccessor(SyntaxKind.AddKeyword).AttributeLists, (parentSyntax, childSyntax) => CreateAccessorAttributes(parentSyntax, childSyntax, SyntaxKind.AddKeyword)); addBody = new CachedChildNode <EventPropertyWithCodeAnalysis, EventDeclarationSyntax, MethodBodyWithCodeAnalysis, BlockSyntax>( node, () => new MethodBodyWithCodeAnalysis(), syntax => syntax.GetAccessor(SyntaxKind.AddKeyword).Body, (parentSyntax, childSyntax) => parentSyntax.WithBody(childSyntax, SyntaxKind.AddKeyword)); attributes = new AttributeListWrapper <EventPropertyWithCodeAnalysis, EventDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); eventType = new CachedChildNode <EventPropertyWithCodeAnalysis, EventDeclarationSyntax, DelegateReferenceWithCodeAnalysis, NameSyntax>( node, () => new DelegateReferenceWithCodeAnalysis(new UnspecifiedTypeReferenceWithCodeAnalysis()), syntax => (NameSyntax)syntax.Type, (parentSyntax, childSyntax) => parentSyntax.WithType(childSyntax)); removeAttributes = new AttributeListWrapper <EventPropertyWithCodeAnalysis, EventDeclarationSyntax>( node, syntax => syntax.GetAccessor(SyntaxKind.RemoveKeyword).AttributeLists, (parentSyntax, childSyntax) => CreateAccessorAttributes(parentSyntax, childSyntax, SyntaxKind.RemoveKeyword)); removeBody = new CachedChildNode <EventPropertyWithCodeAnalysis, EventDeclarationSyntax, MethodBodyWithCodeAnalysis, BlockSyntax>( node, () => new MethodBodyWithCodeAnalysis(), syntax => syntax.GetAccessor(SyntaxKind.RemoveKeyword).Body, (parentSyntax, childSyntax) => parentSyntax.WithBody(childSyntax, SyntaxKind.RemoveKeyword)); }
internal EnumMemberWithCodeAnalysis() { node = new Node <EnumMemberWithCodeAnalysis, EnumMemberDeclarationSyntax>(this); attributes = new AttributeListWrapper <EnumMemberWithCodeAnalysis, EnumMemberDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); }
internal StaticConstructorWithCodeAnalysis() { node = new Node <StaticConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>(this); attributes = new AttributeListWrapper <StaticConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); body = new MethodBodyNode <StaticConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>( node, syntax => syntax.Body, (parentSyntax, childSyntax) => parentSyntax.WithBody(childSyntax)); }
internal AccessorWithCodeAnalysis(AccessorDeclarationSyntax initialSyntax) { node = new Node <AccessorWithCodeAnalysis, AccessorDeclarationSyntax>(this); attributes = new AttributeListWrapper <AccessorWithCodeAnalysis, AccessorDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); if (initialSyntax != null) { Syntax = initialSyntax; } }
internal ParameterWithCodeAnalysis() { node = new Node <ParameterWithCodeAnalysis, ParameterSyntax>(this); attributes = new AttributeListWrapper <ParameterWithCodeAnalysis, ParameterSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); parameterType = new CachedTypeReferenceNode <ParameterWithCodeAnalysis, ParameterSyntax>( node, syntax => syntax.Type, (parentSyntax, childSyntax) => parentSyntax.WithType(childSyntax)); }
internal NestedEnumWithCodeAnalysis() { node = new Node <NestedEnumWithCodeAnalysis, EnumDeclarationSyntax>(this); attributes = new AttributeListWrapper <NestedEnumWithCodeAnalysis, EnumDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); enumMembers = new SeparatedSyntaxNodeList <NestedEnumWithCodeAnalysis, EnumDeclarationSyntax, NestedEnumMemberWithCodeAnalysis, EnumMemberDeclarationSyntax>( node, syntax => syntax.Members, (parentSyntax, childSyntax) => parentSyntax.WithMembers(childSyntax), () => new NestedEnumMemberWithCodeAnalysis()); }
internal EventWithCodeAnalysis() { node = new Node <EventWithCodeAnalysis, EventFieldDeclarationSyntax>(this); attributes = new AttributeListWrapper <EventWithCodeAnalysis, EventFieldDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); eventType = new CachedChildNode <EventWithCodeAnalysis, EventFieldDeclarationSyntax, DelegateReferenceWithCodeAnalysis, NameSyntax>( node, () => new DelegateReferenceWithCodeAnalysis(new UnspecifiedTypeReferenceWithCodeAnalysis()), syntax => (NameSyntax)syntax.Declaration.Type, (parentSyntax, childSyntax) => parentSyntax.WithDeclaration(parentSyntax.Declaration.WithType(childSyntax))); }
internal PropertyWithCodeAnalysis() { node = new Node <PropertyWithCodeAnalysis, PropertyDeclarationSyntax>(this); attributes = new AttributeListWrapper <PropertyWithCodeAnalysis, PropertyDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); propertyType = new CachedTypeReferenceNode <PropertyWithCodeAnalysis, PropertyDeclarationSyntax>( node, syntax => syntax.Type, (parentSyntax, childSyntax) => parentSyntax.WithType(childSyntax)); getAccessor = GetAccessorNode(SyntaxKind.GetKeyword); setAccessor = GetAccessorNode(SyntaxKind.SetKeyword); }
internal EnumWithCodeAnalysis(DocumentWithCodeAnalysis document) { node = new Node <EnumWithCodeAnalysis, EnumDeclarationSyntax>(this); this.document = document; attributes = new AttributeListWrapper <EnumWithCodeAnalysis, EnumDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); enumMembers = new SeparatedSyntaxNodeList <EnumWithCodeAnalysis, EnumDeclarationSyntax, EnumMemberWithCodeAnalysis, EnumMemberDeclarationSyntax>( node, syntax => syntax.Members, (parentSyntax, childSyntax) => parentSyntax.WithMembers(childSyntax), () => new EnumMemberWithCodeAnalysis()); }
public InternalStaticTypeWithCodeAnalysis(TClass @class) { node = new Node <TClass, ClassDeclarationSyntax>(@class); attributes = new AttributeListWrapper <TClass, ClassDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); classes = new InternalStaticClassNestedClassCollectionWithCodeAnalysis <TClass>(this); delegates = new ClassMemberListWrapper <TClass, StaticClassNestedDelegateWithCodeAnalysis, DelegateDeclarationSyntax>( node, () => new StaticClassNestedDelegateWithCodeAnalysis()); enums = new ClassMemberListWrapper <TClass, StaticClassNestedEnumWithCodeAnalysis, EnumDeclarationSyntax>( node, () => new StaticClassNestedEnumWithCodeAnalysis()); events = new InternalStaticClassEventCollectionWithCodeAnalysis <TClass>(this); fields = new InternalStaticClassFieldCollectionWithCodeAnalysis <TClass>(this); genericParameters = new GenericParameterDeclarationNodeList <TClass, ClassDeclarationSyntax>( node, syntax => syntax.TypeParameterList, (parentSyntax, childSyntax) => parentSyntax.WithTypeParameterList(childSyntax), syntax => syntax.ConstraintClauses, (parentSyntax, childSyntax) => parentSyntax.WithConstraintClauses(childSyntax)); interfaces = new ClassMemberListWrapper <TClass, StaticClassNestedInterfaceWithCodeAnalysis, InterfaceDeclarationSyntax>( node, () => new StaticClassNestedInterfaceWithCodeAnalysis()); methods = new InternalStaticClassMethodCollectionWithCodeAnalysis <TClass>(this); properties = new InternalStaticClassPropertyCollectionWithCodeAnalysis <TClass>(this); staticConstructor = new ClassMemberListWrapper <TClass, StaticConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>( node, () => new StaticConstructorWithCodeAnalysis()); structs = new InternalStaticClassNestedStructCollectionWithCodeAnalysis <TClass>(this); members = new MemberList <TClass, ClassDeclarationSyntax>( node, (parentSyntax, childSyntax) => parentSyntax.WithMembers(childSyntax)) { { nameof(fields.Constants), () => fields.Constants.Select(item => item.Syntax) }, { nameof(fields.Fields), () => fields.Fields.Select(item => item.Syntax) }, { nameof(Enums), () => enums.Select(item => item.Syntax) }, { nameof(Delegates), () => delegates.Select(item => item.Syntax) }, { nameof(events.Events), () => events.Events.Select(item => item.Syntax) }, { nameof(events.EventProperties), () => events.EventProperties.Select(item => item.Syntax) }, { nameof(Interfaces), () => interfaces.Select(item => item.Syntax) }, { nameof(Properties), () => Properties.Select(item => item.Syntax) }, { nameof(methods.ExtensionMethods), () => methods.ExtensionMethods.Select(item => item.Syntax) }, { nameof(methods.Methods), () => methods.Methods.Select(item => item.Syntax) } }; }
internal ConstantGroupWithCodeAnalysis() { node = new Node <ConstantGroupWithCodeAnalysis, FieldDeclarationSyntax>(this); attributes = new AttributeListWrapper <ConstantGroupWithCodeAnalysis, FieldDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); constants = new SeparatedSyntaxNodeList <ConstantGroupWithCodeAnalysis, FieldDeclarationSyntax, ConstantWithCodeAnalysis, VariableDeclaratorSyntax>( node, syntax => syntax.Declaration.Variables, (parentSyntax, childSyntax) => parentSyntax.WithDeclaration(parentSyntax.Declaration.WithVariables(childSyntax)), () => new ConstantWithCodeAnalysis()); constantType = new CachedTypeReferenceNode <ConstantGroupWithCodeAnalysis, FieldDeclarationSyntax>( node, syntax => syntax.Declaration.Type, (parentSyntax, childSyntax) => parentSyntax.WithDeclaration(parentSyntax.Declaration.WithType(childSyntax))); }
internal ConstructorWithCodeAnalysis() { node = new Node <ConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>(this); attributes = new AttributeListWrapper <ConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); body = new MethodBodyNode <ConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>( node, syntax => syntax.Body, (parentSyntax, childSyntax) => parentSyntax.WithBody(childSyntax)); parameters = new SeparatedSyntaxNodeList <ConstructorWithCodeAnalysis, ConstructorDeclarationSyntax, ConstructorParameterWithCodeAnalysis, ParameterSyntax>( node, syntax => syntax.ParameterList.Parameters, (parentSyntax, childSyntax) => parentSyntax.WithParameterList(parentSyntax.ParameterList.WithParameters(childSyntax)), () => new ConstructorParameterWithCodeAnalysis()); }
internal LoadedDocumentWithCodeAnalysis(DocumentWithCodeAnalysis document, CompilationUnitSyntax syntax) { this.document = document; node = new Node <LoadedDocumentWithCodeAnalysis, CompilationUnitSyntax>(this, syntax); attributes = new AttributeListWrapper <LoadedDocumentWithCodeAnalysis, CompilationUnitSyntax>( node, parentSyntax => parentSyntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); assemblyAttributes = new FilteredAttributeList(attributes, attribute => attribute.Syntax.Target.Identifier.Text == "assembly"); classes = new ClassCollectionWithCodeAnalysis(this); delegates = new LoadedDocumentMemberListWrapper <DelegateWithCodeAnalysis, DelegateDeclarationSyntax>( node, () => new DelegateWithCodeAnalysis(document)); enums = new LoadedDocumentMemberListWrapper <EnumWithCodeAnalysis, EnumDeclarationSyntax>( node, () => new EnumWithCodeAnalysis(document)); interfaces = new LoadedDocumentMemberListWrapper <InterfaceWithCodeAnalysis, InterfaceDeclarationSyntax>( node, () => new InterfaceWithCodeAnalysis(document)); moduleAttributes = new FilteredAttributeList(attributes, attribute => attribute.Syntax.Target.Identifier.Text == "module"); namespaces = new LoadedDocumentMemberListWrapper <NamespaceWithCodeAnalysis, NamespaceDeclarationSyntax>( node, () => new NamespaceWithCodeAnalysis(document)); structs = new StructCollectionWithCodeAnalysis(this); usingDirectives = new SyntaxNodeList <LoadedDocumentWithCodeAnalysis, CompilationUnitSyntax, UsingDirectiveWithCodeAnalysis, UsingDirectiveSyntax>( node, currentSyntax => currentSyntax.Usings, (parentSyntax, childSyntax) => parentSyntax.WithUsings(childSyntax), () => new UsingDirectiveWithCodeAnalysis()); members = new MemberList <LoadedDocumentWithCodeAnalysis, CompilationUnitSyntax>( node, (parentSyntax, childSyntax) => parentSyntax.WithMembers(childSyntax)) { { nameof(classes.Classes), () => classes.Classes.Select(item => item.Syntax) }, { nameof(classes.AbstractClasses), () => classes.AbstractClasses.Select(item => item.Syntax) }, { nameof(classes.SealedClasses), () => classes.SealedClasses.Select(item => item.Syntax) }, { nameof(classes.StaticClasses), () => classes.StaticClasses.Select(item => item.Syntax) }, { nameof(Delegates), () => delegates.Select(item => item.Syntax) }, { nameof(Enums), () => enums.Select(item => item.Syntax) }, { nameof(Interfaces), () => interfaces.Select(item => item.Syntax) }, { nameof(Namespaces), () => namespaces.Select(item => item.Syntax) }, { nameof(structs.Structs), () => structs.Structs.Select(item => item.Syntax) } }; }
internal IndexerWithCodeAnalysis() { node = new Node <IndexerWithCodeAnalysis, IndexerDeclarationSyntax>(this); attributes = new AttributeListWrapper <IndexerWithCodeAnalysis, IndexerDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); getAccessor = GetAccessorNode(SyntaxKind.GetKeyword); indexerType = new CachedTypeReferenceNode <IndexerWithCodeAnalysis, IndexerDeclarationSyntax>( node, syntax => syntax.Type, (parentSyntax, childSyntax) => parentSyntax.WithType(childSyntax)); parameters = new SeparatedSyntaxNodeList <IndexerWithCodeAnalysis, IndexerDeclarationSyntax, IndexerParameterWithCodeAnalysis, ParameterSyntax>( node, syntax => syntax.ParameterList.Parameters, (parentSyntax, childSyntax) => parentSyntax.WithParameterList(parentSyntax.ParameterList.WithParameters(childSyntax)), () => new IndexerParameterWithCodeAnalysis()); setAccessor = GetAccessorNode(SyntaxKind.SetKeyword); }
internal OperatorOverloadWithCodeAnalysis() { node = new Node <OperatorOverloadWithCodeAnalysis, OperatorDeclarationSyntax>(this); attributes = new AttributeListWrapper <OperatorOverloadWithCodeAnalysis, OperatorDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); body = new MethodBodyNode <OperatorOverloadWithCodeAnalysis, OperatorDeclarationSyntax>( node, syntax => syntax.Body, (parentSyntax, childSyntax) => parentSyntax.WithBody(childSyntax)); parameters = new SeparatedSyntaxNodeList <OperatorOverloadWithCodeAnalysis, OperatorDeclarationSyntax, OperatorParameterWithCodeAnalysis, ParameterSyntax>( node, syntax => syntax.ParameterList.Parameters, (parentSyntax, childSyntax) => parentSyntax.WithParameterList(parentSyntax.ParameterList.WithParameters(childSyntax)), () => new OperatorParameterWithCodeAnalysis()); returnType = new CachedTypeReferenceNode <OperatorOverloadWithCodeAnalysis, OperatorDeclarationSyntax>( node, syntax => syntax.ReturnType, (parentSyntax, childSyntax) => parentSyntax.WithReturnType(childSyntax)); }
internal ConversionOperatorWithCodeAnalysis() { node = new Node <ConversionOperatorWithCodeAnalysis, ConversionOperatorDeclarationSyntax>(this); attributes = new AttributeListWrapper <ConversionOperatorWithCodeAnalysis, ConversionOperatorDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); body = new MethodBodyNode <ConversionOperatorWithCodeAnalysis, ConversionOperatorDeclarationSyntax>( node, syntax => syntax.Body, (parentSyntax, childSyntax) => parentSyntax.WithBody(childSyntax)); parameter = new CachedChildNode <ConversionOperatorWithCodeAnalysis, ConversionOperatorDeclarationSyntax, OperatorParameterWithCodeAnalysis, ParameterSyntax>( node, () => new OperatorParameterWithCodeAnalysis(), syntax => syntax.ParameterList.Parameters[0], WithParameter); returnType = new CachedTypeReferenceNode <ConversionOperatorWithCodeAnalysis, ConversionOperatorDeclarationSyntax>( node, syntax => syntax.Type, (parentSyntax, childSyntax) => parentSyntax.WithType(childSyntax)); }
internal InterfaceTypeWithCodeAnalysis() { node = new Node <InterfaceTypeWithCodeAnalysis, InterfaceDeclarationSyntax>(this); attributes = new AttributeListWrapper <InterfaceTypeWithCodeAnalysis, InterfaceDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); events = new InterfaceMemberListWrapper <InterfaceEventWithCodeAnalysis, EventFieldDeclarationSyntax>( node, () => new InterfaceEventWithCodeAnalysis()); genericParameters = new GenericParameterDeclarationNodeList <InterfaceTypeWithCodeAnalysis, InterfaceDeclarationSyntax>( node, syntax => syntax.TypeParameterList, (parentSyntax, childSyntax) => parentSyntax.WithTypeParameterList(childSyntax), syntax => syntax.ConstraintClauses, (parentSyntax, childSyntax) => parentSyntax.WithConstraintClauses(childSyntax)); interfaces = new BaseTypeNodeList <InterfaceTypeWithCodeAnalysis, InterfaceDeclarationSyntax>( node, (parentSyntax, childSyntax) => parentSyntax.WithBaseList(childSyntax)); properties = new InterfaceMemberListWrapper <InterfacePropertyWithCodeAnalysis, PropertyDeclarationSyntax>( node, () => new InterfacePropertyWithCodeAnalysis()); indexers = new InterfaceMemberListWrapper <InterfaceIndexerWithCodeAnalysis, IndexerDeclarationSyntax>( node, () => new InterfaceIndexerWithCodeAnalysis()); methods = new InterfaceMemberListWrapper <InterfaceMethodWithCodeAnalysis, MethodDeclarationSyntax>( node, () => new InterfaceMethodWithCodeAnalysis()); members = new MemberList <InterfaceTypeWithCodeAnalysis, InterfaceDeclarationSyntax>( node, (parentSyntax, childSyntax) => parentSyntax.WithMembers(childSyntax)) { { nameof(events), () => events.Select(@event => @event.Syntax) }, { nameof(properties), () => properties.Select(property => property.Syntax) }, { nameof(indexers), () => indexers.Select(indexer => indexer.Syntax) }, { nameof(methods), () => methods.Select(method => method.Syntax) } }; }
internal MethodWithCodeAnalysis() { node = new Node<MethodWithCodeAnalysis, MethodDeclarationSyntax>(this); attributes = new AttributeListWrapper<MethodWithCodeAnalysis, MethodDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); genericParameters = new GenericParameterDeclarationNodeList<MethodWithCodeAnalysis, MethodDeclarationSyntax>( node, syntax => syntax.TypeParameterList, (parentSyntax, childSyntax) => parentSyntax.WithTypeParameterList(childSyntax), syntax => syntax.ConstraintClauses, (parentSyntax, childSyntax) => parentSyntax.WithConstraintClauses(childSyntax)); parameters = new SeparatedSyntaxNodeList<MethodWithCodeAnalysis, MethodDeclarationSyntax, MethodParameterWithCodeAnalysis, ParameterSyntax>( node, syntax => syntax.ParameterList.Parameters, (parentSyntax, childSyntax) => parentSyntax.WithParameterList(parentSyntax.ParameterList.WithParameters(childSyntax)), () => new MethodParameterWithCodeAnalysis()); returnType = new CachedTypeReferenceNode<MethodWithCodeAnalysis, MethodDeclarationSyntax>( node, syntax => syntax.ReturnType, (parentSyntax, childSyntax) => parentSyntax.WithReturnType(childSyntax)); }
internal InternalStructTypeWithCodeAnalysis(TStruct @struct) { node = new Node <TStruct, StructDeclarationSyntax>(@struct); attributes = new AttributeListWrapper <TStruct, StructDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); classes = new InternalStructNestedClassCollectionWithCodeAnalysis <TStruct>(this); constructors = new StructTypeMemberListWrapper <TStruct, StructConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>( node, () => new StructConstructorWithCodeAnalysis(), syntax => !syntax.IsStatic()); conversionOperators = new StructTypeMemberListWrapper <TStruct, ConversionOperatorWithCodeAnalysis, ConversionOperatorDeclarationSyntax>( node, () => new ConversionOperatorWithCodeAnalysis()); delegates = new StructTypeMemberListWrapper <TStruct, StructNestedDelegateWithCodeAnalysis, DelegateDeclarationSyntax>( node, () => new StructNestedDelegateWithCodeAnalysis()); enums = new StructTypeMemberListWrapper <TStruct, StructNestedEnumWithCodeAnalysis, EnumDeclarationSyntax>( node, () => new StructNestedEnumWithCodeAnalysis()); events = new InternalStructEventCollectionWithCodeAnalysis <TStruct>(this); fields = new InternalStructFieldCollectionWithCodeAnalysis <TStruct>(this); genericParameters = new GenericParameterDeclarationNodeList <TStruct, StructDeclarationSyntax>( node, syntax => syntax.TypeParameterList, (parentSyntax, childSyntax) => parentSyntax.WithTypeParameterList(childSyntax), syntax => syntax.ConstraintClauses, (parentSyntax, childSyntax) => parentSyntax.WithConstraintClauses(childSyntax)); implementedInterfaces = new BaseTypeNodeList <TStruct, StructDeclarationSyntax>( node, (parentSyntax, childSyntax) => parentSyntax.WithBaseList(childSyntax)); indexers = new InternalStructIndexerCollectionWithCodeAnalysis <TStruct>(this); interfaces = new StructTypeMemberListWrapper <TStruct, StructNestedInterfaceWithCodeAnalysis, InterfaceDeclarationSyntax>( node, () => new StructNestedInterfaceWithCodeAnalysis()); methods = new InternalStructMethodCollectionWithCodeAnalysis <TStruct>(this); operatorOverloads = new StructTypeMemberListWrapper <TStruct, OperatorOverloadWithCodeAnalysis, OperatorDeclarationSyntax>( node, () => new OperatorOverloadWithCodeAnalysis()); properties = new InternalStructPropertyCollectionWithCodeAnalysis <TStruct>(this); staticConstructor = new StructTypeMemberListWrapper <TStruct, StaticConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>( node, () => new StaticConstructorWithCodeAnalysis(), syntax => syntax.IsStatic()); structs = new InternalStructNestedStructCollectionWithCodeAnalysis <TStruct>(this); members = new MemberList <TStruct, StructDeclarationSyntax>( node, (parentSyntax, childSyntax) => parentSyntax.WithMembers(childSyntax)) { { nameof(fields.Constants), () => fields.Constants.Select(item => item.Syntax) }, { nameof(fields.Fields), () => fields.Fields.Select(item => item.Syntax) }, { nameof(Enums), () => enums.Select(item => item.Syntax) }, { nameof(events.Events), () => events.Events.Select(item => item.Syntax) }, { nameof(events.EventProperties), () => events.EventProperties.Select(item => item.Syntax) }, { nameof(events.ExplicitInterfaceEvents), () => events.ExplicitInterfaceEvents.Select(item => item.Syntax) }, { nameof(Constructors), () => constructors.Select(item => item.Syntax) }, { nameof(properties.Properties), () => properties.Properties.Select(item => item.Syntax) }, { nameof(properties.ExplicitInterfaceProperties), () => properties.ExplicitInterfaceProperties.Select(item => item.Syntax) }, { nameof(indexers.Indexers), () => indexers.Indexers.Select(item => item.Syntax) }, { nameof(indexers.ExplicitInterfaceIndexers), () => indexers.ExplicitInterfaceIndexers.Select(item => item.Syntax) }, { nameof(methods.Methods), () => methods.Methods.Select(item => item.Syntax) }, { nameof(methods.ExplicitInterfaceMethods), () => methods.ExplicitInterfaceMethods.Select(item => item.Syntax) }, { nameof(OperatorOverloads), () => operatorOverloads.Select(item => item.Syntax) }, { nameof(ConversionOperators), () => conversionOperators.Select(item => item.Syntax) }, }; }
internal InternalClassTypeWithCodeAnalysis(TClass @class) { node = new Node <TClass, ClassDeclarationSyntax>(@class); baseTypes = new BaseTypeNodeList <TClass, ClassDeclarationSyntax>( node, (parentSyntax, childSyntax) => parentSyntax.WithBaseList(childSyntax)); attributes = new AttributeListWrapper <TClass, ClassDeclarationSyntax>( node, syntax => syntax.AttributeLists, (parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax)); baseClass = new WrappedList <InterfaceReferenceWithCodeAnalysis, ClassReferenceWithCodeAnalysis>( baseTypes, @interface => new ClassReferenceWithCodeAnalysis(@interface.TypeReference), newClass => new InterfaceReferenceWithCodeAnalysis(newClass.TypeReference), classToFilter => !Regex.IsMatch(classToFilter.Name, "^I[A-Z]")); classes = new InternalClassNestedClassCollectionWithCodeAnalysis <TClass>(this); constructors = new ClassMemberListWrapper <TClass, ClassConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>( node, () => new ClassConstructorWithCodeAnalysis(), syntax => !syntax.IsStatic()); conversionOperators = new ClassMemberListWrapper <TClass, ClassConversionOperatorWithCodeAnalysis, ConversionOperatorDeclarationSyntax>( node, () => new ClassConversionOperatorWithCodeAnalysis()); destructor = new ClassMemberListWrapper <TClass, ClassDestructorWithCodeAnalysis, DestructorDeclarationSyntax>( node, () => new ClassDestructorWithCodeAnalysis()); delegates = new ClassMemberListWrapper <TClass, ClassNestedDelegateWithCodeAnalysis, DelegateDeclarationSyntax>( node, () => new ClassNestedDelegateWithCodeAnalysis()); enums = new ClassMemberListWrapper <TClass, ClassNestedEnumWithCodeAnalysis, EnumDeclarationSyntax>( node, () => new ClassNestedEnumWithCodeAnalysis()); events = new InternalClassEventCollectionWithCodeAnalysis <TClass>(this); fields = new InternalClassFieldCollectionWithCodeAnalysis <TClass>(this); genericParameters = new GenericParameterDeclarationNodeList <TClass, ClassDeclarationSyntax>( node, syntax => syntax.TypeParameterList, (parentSyntax, childSyntax) => parentSyntax.WithTypeParameterList(childSyntax), syntax => syntax.ConstraintClauses, (parentSyntax, childSyntax) => parentSyntax.WithConstraintClauses(childSyntax)); implementedInterfaces = new FilteredList <InterfaceReferenceWithCodeAnalysis>( baseTypes, @interface => Regex.IsMatch(@interface.Name, "^I[A-Z]")); indexers = new InternalClassIndexerCollectionWithCodeAnalysis <TClass>(this); interfaces = new ClassMemberListWrapper <TClass, ClassNestedInterfaceWithCodeAnalysis, InterfaceDeclarationSyntax>( node, () => new ClassNestedInterfaceWithCodeAnalysis()); methods = new InternalClassMethodCollectionWithCodeAnalysis <TClass>(this); operatorOverloads = new ClassMemberListWrapper <TClass, ClassOperatorOverloadWithCodeAnalysis, OperatorDeclarationSyntax>( node, () => new ClassOperatorOverloadWithCodeAnalysis()); properties = new InternalClassPropertyCollectionWithCodeAnalysis <TClass>(this); staticConstructor = new ClassMemberListWrapper <TClass, ClassStaticConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>( node, () => new ClassStaticConstructorWithCodeAnalysis(), syntax => syntax.IsStatic()); structs = new InternalClassNestedStructCollectionWithCodeAnalysis <TClass>(this); members = new ClassMemberList <TClass>(node, (parentSyntax, childSyntax) => parentSyntax.WithMembers(childSyntax)) { { nameof(fields.Constants), () => fields.Constants.Select(item => item.Syntax) }, { nameof(fields.Fields), () => fields.Fields.Select(item => item.Syntax) }, { nameof(Enums), () => enums.Select(item => item.Syntax) }, { nameof(Delegates), () => delegates.Select(item => item.Syntax) }, { nameof(events.Events), () => events.Events.Select(item => item.Syntax) }, { nameof(events.EventProperties), () => events.EventProperties.Select(item => item.Syntax) }, { nameof(events.ExplicitInterfaceEvents), () => events.ExplicitInterfaceEvents.Select(item => item.Syntax) }, { nameof(StaticConstructor), () => staticConstructor.Select(item => item.Syntax) }, { nameof(Constructors), () => constructors.Select(item => item.Syntax) }, { nameof(properties.Properties), () => properties.Properties.Select(item => item.Syntax) }, { nameof(properties.ExplicitInterfaceProperties), () => properties.ExplicitInterfaceProperties.Select(item => item.Syntax) }, { nameof(indexers.Indexers), () => indexers.Indexers.Select(item => item.Syntax) }, { nameof(indexers.ExplicitInterfaceIndexers), () => indexers.ExplicitInterfaceIndexers.Select(item => item.Syntax) }, { nameof(methods.Methods), () => methods.Methods.Select(item => item.Syntax) }, { nameof(methods.ExplicitInterfaceMethods), () => methods.ExplicitInterfaceMethods.Select(item => item.Syntax) }, { nameof(OperatorOverloads), () => operatorOverloads.Select(item => item.Syntax) }, { nameof(ConversionOperators), () => conversionOperators.Select(item => item.Syntax) }, { nameof(classes.Classes), () => classes.Classes.Select(item => item.Syntax) }, { nameof(classes.AbstractClasses), () => classes.AbstractClasses.Select(item => item.Syntax) }, { nameof(classes.SealedClasses), () => classes.SealedClasses.Select(item => item.Syntax) }, { nameof(classes.StaticClasses), () => classes.StaticClasses.Select(item => item.Syntax) }, { nameof(Interfaces), () => interfaces.Select(item => item.Syntax) } }; }