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