//-----------------------------------------------------------------------------------------------------------------------------------------------------
public TypeMember(MemberVisibility visibility, TypeMemberKind typeKind, string name, params TypeMember[] genericArguments)
: this()
{
this.Visibility = visibility;
this.TypeKind = typeKind;
this.Name = name;
if (genericArguments != null)
{
this.IsGenericType = (genericArguments.Length > 0);
if (this.IsGenericType)
{
this.IsGenericTypeDefinition = genericArguments.Any(arg => arg.TypeKind == TypeMemberKind.GenericParameter);
if (this.IsGenericTypeDefinition)
{
this.GenericTypeParameters.AddRange(genericArguments);
}
else
{
this.GenericTypeArguments.AddRange(genericArguments);
}
}
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public TypeMember(
TypeGeneratorInfo generator,
string namespaceName,
MemberVisibility visibility,
TypeMemberKind typeKind,
string name,
params TypeMember[] genericTypeArguments)
: this(namespaceName, visibility, typeKind, name, genericTypeArguments)
{
this.Generator = generator;
}
public static TypeMember BuildTypeMember(TypeMemberKind typeKind, IdentifierName name, Action body)
{
var context = CodeGeneratorContext.GetContextOrThrow();
var module = context.TryLookupState <ModuleMember>();
var namespaceContext = context.TryLookupState <NamespaceContext>();
var traits = context.PopStateOrThrow <MemberTraitsContext>();
var containingType = context.TryLookupState <TypeMember>();
var type = new TypeMember();
type.Name = name;
type.Namespace = namespaceContext?.Name;
type.TypeKind = typeKind;
type.DeclaringModule = module;
type.DeclaringType = containingType;
type.Modifier = traits.Modifier;
type.Visibility = traits.Visibility;
type.IsDefaultExport = traits.IsDefaultExport;
if (containingType != null)
{
containingType.Members.Add(type);
}
context.AddGeneratedMember(type, isTopLevel: containingType == null);
if (module != null)
{
module.Members.Add(type);
}
using (context.PushState(type))
{
body?.Invoke();
}
return(type);
}
public static TypeMember BuildType(TypeMemberKind typeKind, string name, Action body)
{
var context = GetContextOrThrow();
var modifiers = context.PopStateOrThrow <MemberModifierState>();
var namespaceState = context.TryLookupState <NamespaceState>();
var containingTypeRef = context.TryLookupState <MemberRef <TypeMember> >();
var builder = new TypeMemberBuilder();
builder.Namespace = namespaceState?.Name;
builder.Name = name;
builder.TypeKind = typeKind;
builder.DeclaringType = containingTypeRef;
using (context.PushState(builder.UnderlyingType))
{
body?.Invoke();
}
var finalMember = new RealTypeMember(builder);
builder.GetMemberSelfReference().Reassign(finalMember);
return(finalMember);
}
: super(TypeMemberKind.Constructor) {
this.TypeParameters = new ArrayList<SimpleNameTypeReferenceNode>();
this.Parameters = new ArrayList<ParameterNode>();
this.ConstraintsClauses = new ArrayList<TypeParameterConstraintsClauseNode>();
}
: super(TypeMemberKind.Destructor) {
}
: super(TypeMemberKind.Field) {
this.Declarators = new ArrayList<VariableDeclaratorNode>();
}
: super(TypeMemberKind.Interface) {
this.TypeParameters = new ArrayList<SimpleNameTypeReferenceNode>();
this.InterfaceBase = new ArrayList<TypeReferenceNode>();
this.ConstraintsClauses = new ArrayList<TypeParameterConstraintsClauseNode>();
this.Members = new ArrayList<IInterfaceMember>();
}
: super(TypeMemberKind.Indexer) {
this.Parameters = new ArrayList<ParameterNode>();
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public TypeMember(string namespaceName, MemberVisibility visibility, TypeMemberKind typeKind, string name, params TypeMember[] genericArguments)
: this(visibility, typeKind, name, genericArguments)
{
this.Namespace = namespaceName;
}
protected TypeMemberNode(TypeMemberKind typeMemberKind) {
this.TypeMemberKind = typeMemberKind;
this.Annotations = new ArrayList<AnnotationSectionNode>();
this.Modifiers = EnumSet.noneOf(typeof(Modifier));
}
: super(TypeMemberKind.Property) {
}
