internal InternalSealedClassMethodCollectionWithCodeAnalysis(InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
methods = new ClassMethodListWrapper <TClass, SealedClassMethodWithCodeAnalysis>(
classType.InternalNode,
() => new SealedClassMethodWithCodeAnalysis(),
syntax => syntax.ExplicitInterfaceSpecifier == null);
}
internal InternalSealedClassEventCollectionWithCodeAnalysis(InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
events = new ClassEventListWrapper <TClass, SealedClassEventWithCodeAnalysis>(
classType.InternalNode,
() => new SealedClassEventWithCodeAnalysis());
eventProperties = new ClassEventPropertyListWrapper <TClass, SealedClassEventPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new SealedClassEventPropertyWithCodeAnalysis(),
syntax => syntax.ExplicitInterfaceSpecifier == null);
}
internal InternalClassFieldCollectionWithCodeAnalysis(InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
constants = new ClassMemberListWrapper <TClass, ClassConstantWithCodeAnalysis, FieldDeclarationSyntax>(
classType.InternalNode,
() => new ClassConstantWithCodeAnalysis(),
syntax => syntax.IsConstant());
fields = new ClassMemberListWrapper <TClass, ClassFieldWithCodeAnalysis, FieldDeclarationSyntax>(
classType.InternalNode,
() => new ClassFieldWithCodeAnalysis(),
syntax => !syntax.IsConstant());
}
internal InternalClassNestedStructCollectionWithCodeAnalysis(InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
structs = new ClassMemberListWrapper <TClass, ClassNestedStructWithCodeAnalysis, StructDeclarationSyntax>(
classType.InternalNode,
() => new ClassNestedStructWithCodeAnalysis(),
syntax => !syntax.IsPartial());
partialStructs = new ClassMemberListWrapper <TClass, ClassNestedPartialStructWithCodeAnalysis, StructDeclarationSyntax>(
classType.InternalNode,
() => new ClassNestedPartialStructWithCodeAnalysis(),
StructDeclarationSyntaxExtensions.IsPartial);
}
internal InternalAbstractClassIndexerCollectionWithCodeAnalysis(InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
indexers = new ClassIndexerListWrapper <TClass, AbstractClassIndexerWithCodeAnalysis>(
classType.InternalNode,
() => new AbstractClassIndexerWithCodeAnalysis(),
syntax => syntax.ExplicitInterfaceSpecifier == null && !syntax.Modifiers.IsAbstract());
abstractIndexers = new ClassIndexerListWrapper <TClass, AbstractIndexerWithCodeAnalysis>(
classType.InternalNode,
() => new AbstractIndexerWithCodeAnalysis(),
syntax => syntax.Modifiers.IsAbstract());
}
internal InternalClassIndexerCollectionWithCodeAnalysis(InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
explicitInterfaceIndexers = new ClassIndexerListWrapper <TClass, ExplicitInterfaceIndexerWithCodeAnalysis>(
classType.InternalNode,
() => new ExplicitInterfaceIndexerWithCodeAnalysis(),
syntax => syntax.ExplicitInterfaceSpecifier != null);
indexers = new ClassIndexerListWrapper <TClass, ClassIndexerWithCodeAnalysis>(
classType.InternalNode,
() => new ClassIndexerWithCodeAnalysis(),
syntax => syntax.ExplicitInterfaceSpecifier == null);
}
internal InternalSealedClassPropertyCollectionWithCodeAnalysis(InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
properties = new ClassPropertyListWrapper <TClass, SealedClassPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new SealedClassPropertyWithCodeAnalysis(),
syntax => syntax.IsProperty());
autoProperties = new ClassPropertyListWrapper <TClass, SealedClassAutoPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new SealedClassAutoPropertyWithCodeAnalysis(),
syntax => syntax.IsAutoProperty());
lambdaProperties = new ClassPropertyListWrapper <TClass, SealedClassLambdaPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new SealedClassLambdaPropertyWithCodeAnalysis(),
syntax => syntax.IsLambdaProperty());
}
internal InternalAbstractClassEventCollectionWithCodeAnalysis(InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
events = new ClassEventListWrapper <TClass, AbstractClassEventWithCodeAnalysis>(
classType.InternalNode,
() => new AbstractClassEventWithCodeAnalysis(),
syntax => !syntax.Modifiers.IsAbstract());
eventProperties = new WrappedCollection <ClassEventPropertyWithCodeAnalysis, AbstractClassEventPropertyWithCodeAnalysis>(
classType.Events.EventProperties,
parent => new AbstractClassEventPropertyWithCodeAnalysis(parent),
child => child.EventProperty,
value => classType.Events.EventProperties = value);
abstractEvents = new ClassEventListWrapper <TClass, AbstractEventWithCodeAnalysis>(
classType.InternalNode,
() => new AbstractEventWithCodeAnalysis(),
syntax => syntax.Modifiers.IsAbstract());
}
internal InternalSealedTypeWithCodeAnalysis(TClass @class)
{
classType = new InternalClassTypeWithCodeAnalysis <TClass>(@class);
members = classType.Members;
classes = new SealedClassNestedClassCollectionWithCodeAnalysis(classType.Classes);
constructors = new WrappedCollection <ClassConstructorWithCodeAnalysis, SealedClassConstructorWithCodeAnalysis>(
classType.Constructors,
constructor => new SealedClassConstructorWithCodeAnalysis(constructor),
constructor => constructor.Constructor,
value => classType.Constructors = value);
conversionOperators = new WrappedCollection <ClassConversionOperatorWithCodeAnalysis, SealedClassConversionOperatorWithCodeAnalysis>(
classType.ConversionOperators,
parent => new SealedClassConversionOperatorWithCodeAnalysis(parent),
child => child.ConversionOperator,
value => classType.ConversionOperators = value);
delegates = new WrappedCollection <ClassNestedDelegateWithCodeAnalysis, SealedClassNestedDelegateWithCodeAnalysis>(
classType.Delegates,
parent => new SealedClassNestedDelegateWithCodeAnalysis(parent),
child => child.Delegate,
value => classType.Delegates = value);
enums = new WrappedCollection <ClassNestedEnumWithCodeAnalysis, SealedClassNestedEnumWithCodeAnalysis>(
classType.Enums,
parent => new SealedClassNestedEnumWithCodeAnalysis(parent),
child => child.Enum,
value => classType.Enums = value);
events = new InternalSealedClassEventCollectionWithCodeAnalysis <TClass>(classType);
fields = new SealedClassFieldCollectionWithCodeAnalysis(classType.Fields);
indexers = new InternalSealedClassIndexerCollectionWithCodeAnalysis <TClass>(classType);
interfaces = new WrappedCollection <ClassNestedInterfaceWithCodeAnalysis, SealedClassNestedInterfaceWithCodeAnalysis>(
classType.Interfaces,
parent => new SealedClassNestedInterfaceWithCodeAnalysis(parent),
child => child.Interface,
value => classType.Interfaces = value);
methods = new InternalSealedClassMethodCollectionWithCodeAnalysis <TClass>(classType);
operatorOverloads = new WrappedCollection <ClassOperatorOverloadWithCodeAnalysis, SealedClassOperatorOverloadWithCodeAnalysis>(
classType.OperatorOverloads,
parent => new SealedClassOperatorOverloadWithCodeAnalysis(parent),
child => child.OperatorOverload,
value => classType.OperatorOverloads = value);
properties = new InternalSealedClassPropertyCollectionWithCodeAnalysis <TClass>(classType);
structs = new SealedClassNestedStructCollectionWithCodeAnalysis(classType.Structs);
InitializeMembers();
}
internal InternalClassPropertyCollectionWithCodeAnalysis(InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
autoProperties = new ClassPropertyListWrapper <TClass, ClassAutoPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new ClassAutoPropertyWithCodeAnalysis(),
syntax => syntax.IsAutoProperty());
explicitInterfaceProperties = new ClassPropertyListWrapper <TClass, ExplicitInterfacePropertyWithCodeAnalysis>(
classType.InternalNode,
() => new ExplicitInterfacePropertyWithCodeAnalysis(),
syntax => syntax.ExplicitInterfaceSpecifier != null);
lambdaProperties = new ClassPropertyListWrapper <TClass, ClassLambdaPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new ClassLambdaPropertyWithCodeAnalysis(),
syntax => syntax.IsLambdaProperty());
properties = new ClassPropertyListWrapper <TClass, ClassPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new ClassPropertyWithCodeAnalysis(),
syntax => syntax.IsProperty());
}
internal InternalClassNestedClassCollectionWithCodeAnalysis(InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
classes = new ClassMemberListWrapper <TClass, ClassNestedClassWithCodeAnalysis, ClassDeclarationSyntax>(
classType.InternalNode,
() => new ClassNestedClassWithCodeAnalysis(),
ClassDeclarationSyntaxExtensions.IsClass);
abstractClasses = new ClassMemberListWrapper <TClass, ClassNestedAbstractClassWithCodeAnalysis, ClassDeclarationSyntax>(
classType.InternalNode,
() => new ClassNestedAbstractClassWithCodeAnalysis(),
ClassDeclarationSyntaxExtensions.IsAbstractClass);
sealedClasses = new ClassMemberListWrapper <TClass, ClassNestedSealedClassWithCodeAnalysis, ClassDeclarationSyntax>(
classType.InternalNode,
() => new ClassNestedSealedClassWithCodeAnalysis(),
ClassDeclarationSyntaxExtensions.IsSealedClass);
staticClasses = new ClassMemberListWrapper <TClass, ClassNestedStaticClassWithCodeAnalysis, ClassDeclarationSyntax>(
classType.InternalNode,
() => new ClassNestedStaticClassWithCodeAnalysis(),
ClassDeclarationSyntaxExtensions.IsStaticClass);
partialClasses = ClassNestedPartialClassCollectionWithCodeAnalysis.Create(classType);
}
internal InternalAbstractClassPropertyCollectionWithCodeAnalysis(
InternalClassTypeWithCodeAnalysis <TClass> classType)
{
this.classType = classType;
properties = new ClassPropertyListWrapper <TClass, AbstractClassPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new AbstractClassPropertyWithCodeAnalysis(),
syntax => syntax.IsProperty());
autoProperties = new ClassPropertyListWrapper <TClass, AbstractClassAutoPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new AbstractClassAutoPropertyWithCodeAnalysis(),
syntax => syntax.IsAutoProperty() && !syntax.Modifiers.IsAbstract());
lambdaProperties = new ClassPropertyListWrapper <TClass, AbstractClassLambdaPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new AbstractClassLambdaPropertyWithCodeAnalysis(),
syntax => syntax.IsLambdaProperty());
abstractProperties = new ClassPropertyListWrapper <TClass, AbstractPropertyWithCodeAnalysis>(
classType.InternalNode,
() => new AbstractPropertyWithCodeAnalysis(),
syntax => syntax.Modifiers.IsAbstract());
}
internal InternalNestedClassWithCodeAnalysis(TClass @class)
{
classType = new InternalClassTypeWithCodeAnalysis <TClass>(@class);
}