public override void VisitEnter(RppClass node)
{
if (node.BaseConstructorCall.BaseClassType2.Value.Name != "Object")
{
node.Type.BaseType = node.BaseConstructorCall.BaseClassType2.Value;
}
}
private void CheckForNonDefinedAbstractMethods(RppClass node)
{
/*
if (node.Modifiers.Contains(ObjectModifier.OmAbstract))
{
}
*/
// TODO not implemented yet
}
public override void VisitEnter(RppClass node)
{
string typeName = node.GetNativeName();
RTypeAttributes typeAttributes = GetTypeAttributes(node);
RType classType;
if (_outterTypes.Any())
{
RType outterType = _outterTypes.Peek();
classType = outterType.DefineNestedType(typeName, typeAttributes, null);
}
else
{
classType = RppTypeSystem.GetOrCreateType(typeName, typeAttributes, null, null);
}
node.Type = classType;
_outterTypes.Push(classType);
string[] typeParamsNames = CombineGenericParameters(node.TypeParams.Select(tp => tp.Name));
classType.DefineGenericParameters(typeParamsNames);
}
public override void VisitEnter(RppClass node)
{
_currentClass = node;
node.ResolveGenericTypeConstraints(_currentClass.Scope, _diagnostic);
}
private static RTypeAttributes GetTypeAttributes(RppClass node)
{
RTypeAttributes attr = node.Kind == ClassKind.Class ? RTypeAttributes.Class : RTypeAttributes.Object;
return attr | GetAttributes(node.Modifiers);
}
public override void VisitExit(RppClass node)
{
_outterTypes.Pop();
}
public override void VisitEnter(RppClass node)
{
node.Type.CreateNativeType();
}
public override void VisitEnter(RppClass node)
{
node.Type.InitializeNativeType(_module);
}
public override void VisitEnter(RppClass node)
{
}
// class Bag[A : Item] -> resolves 'Item' and sets constraint to generic parameter
private void ProcessTypeConstraints(RppClass node)
{
if (_currentType.IsGenericType)
{
_currentClass.ResolveGenericTypeConstraints(_currentClass.Scope, _diagnostic);
ProcessGenerics(node.TypeParams, _currentType.GenericParameters);
}
}
public override void VisitEnter(RppClass node)
{
_currentClass = node;
_currentType = node.Type;
ProcessTypeConstraints(node);
}
public override void VisitExit(RppClass node)
{
TypeBuilder clazz = node.Type.NativeType as TypeBuilder;
Debug.Assert(clazz != null, "clazz != null");
try
{
clazz.CreateType();
} // TODO This is a hack, we should do our own semantic analyzes and find out which methods were not overriden
catch (TypeLoadException exception)
{
MatchCollection groups = TypeExcSplitter.Matches(exception.Message);
if (groups.Count != 3)
{
throw;
}
string msg = $"Method '{groups[0]}' in class '{groups[1]}' does not have an implementation";
throw new SemanticException(105, msg);
}
Console.WriteLine("Generated class");
}
private void CreateStaticConstructor(TypeBuilder typeBuilder, RppField instanceField, RppClass obj)
{
FieldInfo instanceFieldInfo = instanceField.FieldInfo.Native;
ConstructorBuilder staticConstructor = typeBuilder.DefineTypeInitializer();
_body = staticConstructor.GetILGenerator();
instanceField.InitExpr.Accept(this);
_body.Emit(OpCodes.Stsfld, instanceFieldInfo);
_body.Emit(OpCodes.Ret);
}
public override void VisitEnter(RppClass node)
{
Console.WriteLine("Genering class: " + node.Name);
_typeBuilder = node.Type.NativeType as TypeBuilder;
Debug.Assert(_typeBuilder != null, "_typeBuilder != null");
_closureId = 1;
if (node.IsObject())
{
CreateStaticConstructor(_typeBuilder, node.InstanceField, node);
}
}
public override void VisitEnter(RppClass node)
{
CheckForNonDefinedAbstractMethods(node);
}
