private void defineClassMembers(ClassDeclarationNode classDeclaration) {
var typeBuilder = classDeclaration.getUserData(typeof(TypeBuilder));
context.CurrentType = typeBuilder;
context.MemberResolver.enterType(typeBuilder);
try {
setTypeConstraints(classDeclaration.ConstraintsClauses, typeBuilder);
if (typeBuilder.IsEnum) {
var fieldBuilder = typeBuilder.defineField("ENUM$VALUES", typeBuilder.ArrayType);
fieldBuilder.setPrivate(true);
fieldBuilder.setFinal(true);
fieldBuilder.setStatic(true);
var methodBuilder = typeBuilder.defineMethod("valueOf");
methodBuilder.setPublic(true);
methodBuilder.setStatic(true);
methodBuilder.setReturnType(typeBuilder);
var param = methodBuilder.addParameter(context.TypeSystem.StringType);
param.setName("str");
methodBuilder = typeBuilder.defineMethod("values");
methodBuilder.setPublic(true);
methodBuilder.setStatic(true);
methodBuilder.setReturnType(typeBuilder.ArrayType);
}
foreach (var member in classDeclaration.Members) {
switch (member.TypeMemberKind) {
case Class:
defineClassMembers((ClassDeclarationNode)member);
break;
case Interface:
defineInterfaceMembers((InterfaceDeclarationNode)member);
break;
case Delegate:
defineDelegateMembers((DelegateDeclarationNode)member);
break;
case Method:
defineClassMethod((MethodDeclarationNode)member, classDeclaration.IsPartial, typeBuilder);
break;
case Field:
defineClassField((FieldDeclarationNode)member, typeBuilder);
break;
case EnumConstant:
defineEnumConstant((EnumConstantDeclarationNode)member, typeBuilder);
break;
case Indexer:
defineClassIndexer((IndexerDeclarationNode)member, typeBuilder);
break;
case Property:
defineClassProperty((PropertyDeclarationNode)member, typeBuilder);
break;
case Constructor:
defineClassConstructor((ConstructorDeclarationNode)member, typeBuilder);
break;
case Destructor:
defineClassDestructor((DestructorDeclarationNode)member, typeBuilder);
break;
default:
throw new Exception("Internal error: unhandled member kind: " + member.TypeMemberKind);
}
context.CurrentType = typeBuilder;
}
} finally {
context.MemberResolver.leaveType();
}
}
private void setClassBaseTypes(ClassDeclarationNode classDeclaration) {
var typeBuilder = classDeclaration.getUserData(typeof(TypeBuilder));
context.MemberResolver.enterType(typeBuilder);
try {
var first = true;
foreach (var typeReference in classDeclaration.ClassBase) {
var type = CompilerHelper.resolveTypeReference(context, typeBuilder.PackageName, typeReference);
if (first) {
first = false;
if (type.IsInterface) {
typeBuilder.addInterface(type);
} else {
if (type.IsGenericParameter) {
context.addError(CompileErrorId.DeriveFromTypeVariable, typeReference, BytecodeHelper.getDisplayName(type));
continue;
}
if (typeBuilder.BaseType != null && typeBuilder.BaseType != type) {
context.addError(CompileErrorId.DifferentPartialBaseClass,
typeReference, BytecodeHelper.getDisplayName(typeBuilder));
continue;
}
if (type.IsFinal) {
context.addError(CompileErrorId.FinalBaseClass, typeReference,
BytecodeHelper.getDisplayName(typeBuilder), BytecodeHelper.getDisplayName(type));
continue;
}
if ((typeBuilder.IsPublic && !type.IsPublic) ||
(!typeBuilder.IsNestedPrivate && type.IsNestedPrivate)) {
context.addError(CompileErrorId.InconsistentBaseTypeAccessibility, typeReference,
BytecodeHelper.getDisplayName(typeBuilder), BytecodeHelper.getDisplayName(type));
}
typeBuilder.setBaseType(type);
}
} else {
if (!type.IsInterface) {
if (typeBuilder.BaseType != null) {
context.addError(CompileErrorId.MultipleBaseClass, typeReference,
BytecodeHelper.getDisplayName(typeBuilder),
BytecodeHelper.getDisplayName(type),
BytecodeHelper.getDisplayName(typeBuilder.BaseType));
} else {
context.addError(CompileErrorId.BaseClassBeforeInterfaces, typeReference,
BytecodeHelper.getDisplayName(type));
}
}
typeBuilder.addInterface(type);
}
}
if (typeBuilder.BaseType == null) {
if (classDeclaration.IsEnum) {
typeBuilder.setEnum(true);
var enumType = context.TypeSystem.getType("java/lang/Enum");
typeBuilder.setBaseType(context.TypeSystem.getGenericType(enumType, Collections.singletonList<TypeInfo>(typeBuilder)));
} else {
typeBuilder.setBaseType(context.TypeSystem.ObjectType);
}
}
foreach (var member in classDeclaration.Members) {
switch (member.TypeMemberKind) {
case Class:
setClassBaseTypes((ClassDeclarationNode)member);
break;
case Interface:
setInterfaceBaseTypes((InterfaceDeclarationNode)member);
break;
case Delegate:
setDelegateBaseTypes((DelegateDeclarationNode)member);
break;
case Constructor:
case Destructor:
case EnumConstant:
case Field:
case Indexer:
case Method:
case Property:
break;
default:
throw new Exception("Internal error: unhandled member kind: " + member.TypeMemberKind);
}
}
} finally {
context.MemberResolver.leaveType();
}
}
public void enterClass(ClassDeclarationNode declaration) {
typeInfos.add(declaration.getUserData(typeof(TypeInfo)));
}
